Основы кибербезопасности для юных программистов

В цифровом мире, где мы проводим все больше времени онлайн, кибербезопасность становится не менее важной, чем безопасность в реальной жизни. Для юных программистов особенно важно понимать принципы безопасности, ведь они создают программы, которыми будут пользоваться другие люди. В этой статье мы изучим основы кибербезопасности простым и понятным языком, с практическими примерами и советами.

Что такое кибербезопасность и почему она важна?

Кибербезопасность - это защита компьютеров, серверов, мобильных устройств, электронных систем, сетей и данных от злонамеренных атак. Представьте, что интернет - это большой город, а кибербезопасность - это замки, сигнализация и охрана, которые защищают ваш дом.

Почему юным программистам важно знать о безопасности:

Ответственность разработчика

• Ваши программы используют другие люди

• Ошибки в коде могут привести к утечке данных

• Хакеры ищут уязвимости в приложениях

• Безопасность нужно закладывать с самого начала

Защита личной информации

• Пароли и личные данные требуют защиты

• Социальные сети содержат много информации о вас

• Финансовые данные особенно привлекательны для мошенников

• Репутация в интернете влияет на будущие возможности

Понимание угроз

• Вирусы и малware - вредоносные программы

• Фишинг - обман для получения личных данных

• Социальная инженерия - психологические методы обмана

• DDoS атаки - перегрузка серверов

• Инъекции кода - внедрение вредоносного кода

Основные принципы безопасности

Принцип минимальных привилегий

Пользователь или программа должны иметь только те права доступа, которые необходимы для выполнения их функций.

# Плохо: даем администраторские права всем

class User:

    def __init__(self, username):

        self.username = username

        self.is_admin = True  # Опасно!

    def delete_all_data(self):

        # Любой пользователь может удалить все данные

        print("Все данные удалены!")

# Хорошо: разграничиваем права доступа

class User:

    def __init__(self, username, role="user"):

        self.username = username

        self.role = role

    def can_delete_data(self):

        return self.role == "admin"

    def delete_data(self, data_id):

        if not self.can_delete_data():

            raise PermissionError("У вас нет прав для удаления данных")

        print(f"Данные {data_id} удалены пользователем {self.username}")

# Пример использования

обычный_пользователь = User("anna", "user")

администратор = User("admin", "admin")

try:

    обычный_пользователь.delete_data("important_file")

except PermissionError as e:

    print(f"Ошибка: {e}")

администратор.delete_data("old_backup")  # Это разрешено

Защита в глубину (Defense in Depth)

Используйте несколько уровней защиты, а не полагайтесь на одну меру безопасности.

import hashlib

import secrets

import time

from functools import wraps

class SecurityLayer:

    """Многоуровневая система безопасности"""

    def __init__(self):

        self.failed_attempts = {}

        self.blocked_ips = set()

        self.session_tokens = {}

    def hash_password(self, password: str, salt: bytes = None) -> tuple:

        """Уровень 1: Хеширование пароля с солью"""

        if salt is None:

            salt = secrets.token_bytes(32)

        # Используем PBKDF2 для замедления атак

        hashed = hashlib.pbkdf2_hmac('sha256', 

                                   password.encode('utf-8'), 

                                   salt, 

                                   100000)  # 100,000 итераций

        return hashed, salt

    def verify_password(self, password: str, hashed: bytes, salt: bytes) -> bool:

        """Проверка пароля"""

        new_hash, _ = self.hash_password(password, salt)

        return secrets.compare_digest(hashed, new_hash)

    def rate_limit(self, ip_address: str, max_attempts: int = 5) -> bool:

        """Уровень 2: Ограничение количества попыток"""

        current_time = time.time()

        if ip_address in self.blocked_ips:

            return False

        if ip_address not in self.failed_attempts:

            self.failed_attempts[ip_address] = []

        # Очищаем старые попытки (старше часа)

        self.failed_attempts[ip_address] = [

            attempt for attempt in self.failed_attempts[ip_address]

            if current_time - attempt < 3600

        ]

        if len(self.failed_attempts[ip_address]) >= max_attempts:

            self.blocked_ips.add(ip_address)

            print(f"IP {ip_address} заблокирован за превышение лимита попыток")

            return False

        return True

    def log_failed_attempt(self, ip_address: str):

        """Логирование неудачных попыток"""

        if ip_address not in self.failed_attempts:

            self.failed_attempts[ip_address] = []

        self.failed_attempts[ip_address].append(time.time())

        print(f"Неудачная попытка входа с IP {ip_address}")

    def create_session(self, username: str) -> str:

        """Уровень 3: Создание безопасного токена сессии"""

        token = secrets.token_urlsafe(32)

        self.session_tokens[token] = {

            'username': username,

            'created_at': time.time(),

            'expires_at': time.time() + 3600  # 1 час

        }

        return token

    def validate_session(self, token: str) -> str:

        """Проверка токена сессии"""

        if token not in self.session_tokens:

            raise ValueError("Недействительный токен")

        session = self.session_tokens[token]

        if time.time() > session['expires_at']:

            del self.session_tokens[token]

            raise ValueError("Токен истек")

        return session['username']

# Декоратор для проверки авторизации

def require_auth(security_layer):

    def decorator(func):

        @wraps(func)

        def wrapper(*args, **kwargs):

            token = kwargs.get('session_token')

            if not token:

                raise ValueError("Требуется авторизация")

            try:

                username = security_layer.validate_session(token)

                kwargs['current_user'] = username

                return func(*args, **kwargs)

            except ValueError as e:

                print(f"Ошибка авторизации: {e}")

                return None

        return wrapper

    return decorator

# Пример использования

security = SecurityLayer()

class SecureApp:

    def __init__(self):

        self.users = {}  # В реальности это была бы база данных

    def register_user(self, username: str, password: str, ip_address: str):

        """Регистрация пользователя с проверкой лимитов"""

        if not security.rate_limit(ip_address):

            return {"error": "Слишком много попыток. Попробуйте позже."}

        if username in self.users:

            security.log_failed_attempt(ip_address)

            return {"error": "Пользователь уже существует"}

        # Проверяем сложность пароля

        if not self._is_strong_password(password):

            return {"error": "Пароль недостаточно сложный"}

        hashed_password, salt = security.hash_password(password)

        self.users[username] = {

            'password_hash': hashed_password,

            'salt': salt,

            'created_at': time.time()

        }

        print(f"Пользователь {username} успешно зарегистрирован")

        return {"success": True}

    def login(self, username: str, password: str, ip_address: str):

        """Безопасный вход в систему"""

        if not security.rate_limit(ip_address):

            return {"error": "IP заблокирован"}

        if username not in self.users:

            security.log_failed_attempt(ip_address)

            return {"error": "Неверные учетные данные"}

        user_data = self.users[username]

        if security.verify_password(password, 

                                   user_data['password_hash'], 

                                   user_data['salt']):

            session_token = security.create_session(username)

            print(f"Пользователь {username} успешно вошел в систему")

            return {"success": True, "session_token": session_token}

        else:

            security.log_failed_attempt(ip_address)

            return {"error": "Неверные учетные данные"}

    @require_auth(security)

    def get_user_profile(self, session_token=None, current_user=None):

        """Получение профиля пользователя (требует авторизации)"""

        return {

            "username": current_user,

            "message": f"Добро пожаловать, {current_user}!"

        }

    def _is_strong_password(self, password: str) -> bool:

        """Проверка сложности пароля"""

        if len(password) < 8:

            return False

        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 "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password)

        return has_upper and has_lower and has_digit and has_special

# Демонстрация работы

app = SecureApp()

# Регистрация

print("=== РЕГИСТРАЦИЯ ===")

result = app.register_user("anna", "MyP@ssw0rd123", "192.168.1.100")

print(result)

# Попытки входа

print("\n=== ВХОД В СИСТЕМУ ===")

# Неудачная попытка

result = app.login("anna", "wrongpassword", "192.168.1.100")

print(result)

# Успешный вход

result = app.login("anna", "MyP@ssw0rd123", "192.168.1.100")

print(result)

token = result.get("session_token")

# Использование защищенной функции

print("\n=== ДОСТУП К ПРОФИЛЮ ===")

profile = app.get_user_profile(session_token=token)

print(profile)

Проверка и санитизация данных

Никогда не доверяйте пользовательскому вводу - всегда проверяйте и очищайте данные.

import re

import html

import sqlite3

from typing import Optional, List, Dict, Any

class DataValidator:

    """Класс для проверки и санитизации данных"""

    @staticmethod

    def sanitize_string(input_string: str, max_length: int = 255) -> str:

        """Очистка строки от опасных символов"""

        if not isinstance(input_string, str):

            raise TypeError("Ожидается строка")

        # Удаляем HTML теги и специальные символы

        cleaned = html.escape(input_string.strip())

        # Ограничиваем длину

        if len(cleaned) > max_length:

            cleaned = cleaned[:max_length]

        return cleaned

    @staticmethod

    def validate_email(email: str) -> bool:

        """Проверка формата email"""

        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

        return re.match(pattern, email) is not None

    @staticmethod

    def validate_username(username: str) -> tuple[bool, str]:

        """Проверка имени пользователя"""

        if not username:

            return False, "Имя пользователя не может быть пустым"

        if len(username) < 3:

            return False, "Имя пользователя должно содержать минимум 3 символа"

        if len(username) > 20:

            return False, "Имя пользователя не может содержать более 20 символов"

        # Только буквы, цифры и подчеркивания

        if not re.match(r'^[a-zA-Z0-9_]+$', username):

            return False, "Имя пользователя может содержать только буквы, цифры и подчеркивания"

        return True, "OK"

    @staticmethod

    def validate_age(age: Any) -> tuple[bool, str]:

        """Проверка возраста"""

        try:

            age_int = int(age)

            if age_int < 0:

                return False, "Возраст не может быть отрицательным"

            if age_int > 150:

                return False, "Возраст не может быть больше 150 лет"

            return True, "OK"

        except (ValueError, TypeError):

            return False, "Возраст должен быть числом"

class SafeDatabase:

    """Безопасная работа с базой данных"""

    def __init__(self, db_path: str):

        self.db_path = db_path

        self.init_database()

    def init_database(self):

        """Инициализация базы данных"""

        with sqlite3.connect(self.db_path) as conn:

            conn.execute('''

                CREATE TABLE IF NOT EXISTS users (

                    id INTEGER PRIMARY KEY AUTOINCREMENT,

                    username TEXT UNIQUE NOT NULL,

                    email TEXT UNIQUE NOT NULL,

                    age INTEGER NOT NULL,

                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP

                )

            ''')

    def add_user_unsafe(self, username: str, email: str, age: int):

        """ОПАСНЫЙ способ - уязвим к SQL инъекциям"""

        query = f"INSERT INTO users (username, email, age) VALUES ('{username}', '{email}', {age})"

        print(f"ОПАСНЫЙ запрос: {query}")

        # Этот код НЕ ЗАПУСКАЙТЕ в реальном приложении!

        # Пример атаки: username = "'; DROP TABLE users; --"

        # Результат: INSERT INTO users (username, email, age) VALUES (''; DROP TABLE users; --', 'email', 25)

    def add_user_safe(self, username: str, email: str, age: int):

        """БЕЗОПАСНЫЙ способ - использует параметризованные запросы"""

        # Проверяем данные

        validator = DataValidator()

        username = validator.sanitize_string(username, 20)

        is_valid, error = validator.validate_username(username)

        if not is_valid:

            raise ValueError(f"Неверное имя пользователя: {error}")

        if not validator.validate_email(email):

            raise ValueError("Неверный формат email")

        is_valid, error = validator.validate_age(age)

        if not is_valid:

            raise ValueError(f"Неверный возраст: {error}")

        # Безопасный запрос с параметрами

        try:

            with sqlite3.connect(self.db_path) as conn:

                conn.execute(

                    "INSERT INTO users (username, email, age) VALUES (?, ?, ?)",

                    (username, email, age)

                )

                print(f"Пользователь {username} успешно добавлен")

        except sqlite3.IntegrityError:

            raise ValueError("Пользователь с таким именем или email уже существует")

    def get_user_unsafe(self, username: str):

        """ОПАСНЫЙ поиск пользователя"""

        query = f"SELECT * FROM users WHERE username = '{username}'"

        print(f"ОПАСНЫЙ запрос: {query}")

        # Атака: username = "' OR '1'='1"

        # Результат: SELECT * FROM users WHERE username = '' OR '1'='1'

        # Вернет ВСЕХ пользователей!

    def get_user_safe(self, username: str) -> Optional[Dict[str, Any]]:

        """БЕЗОПАСНЫЙ поиск пользователя"""

        username = DataValidator.sanitize_string(username, 20)

        with sqlite3.connect(self.db_path) as conn:

            conn.row_factory = sqlite3.Row

            cursor = conn.execute(

                "SELECT * FROM users WHERE username = ?",

                (username,)

            )

            row = cursor.fetchone()

            if row:

                return dict(row)

            return None

    def search_users_safe(self, search_term: str) -> List[Dict[str, Any]]:

        """Безопасный поиск пользователей"""

        # Очищаем поисковый запрос

        search_term = DataValidator.sanitize_string(search_term, 50)

        # Используем LIKE с экранированием

        with sqlite3.connect(self.db_path) as conn:

            conn.row_factory = sqlite3.Row

            cursor = conn.execute(

                "SELECT username, email FROM users WHERE username LIKE ? ESCAPE '\\'",

                (f"%{search_term}%",)

            )

            return [dict(row) for row in cursor.fetchall()]

# Пример безопасной веб-формы

class SafeWebForm:

    """Безопасная обработка веб-форм"""

    def __init__(self):

        self.validator = DataValidator()

        self.db = SafeDatabase("users.db")

    def process_registration(self, form_data: Dict[str, Any]) -> Dict[str, Any]:

        """Обработка формы регистрации"""

        try:

            # Извлекаем данные из формы

            username = form_data.get('username', '').strip()

            email = form_data.get('email', '').strip()

            age = form_data.get('age', '')

            # Проверяем обязательные поля

            if not all([username, email, age]):

                return {

                    "success": False,

                    "error": "Все поля обязательны для заполнения"

                }

            # Валидация

            username = self.validator.sanitize_string(username, 20)

            email = self.validator.sanitize_string(email, 100)

            is_valid, error = self.validator.validate_username(username)

            if not is_valid:

                return {"success": False, "error": error}

            if not self.validator.validate_email(email):

                return {"success": False, "error": "Неверный формат email"}

            is_valid, error = self.validator.validate_age(age)

            if not is_valid:

                return {"success": False, "error": error}

            # Сохраняем в базу данных

            self.db.add_user_safe(username, email, int(age))

            return {

                "success": True,

                "message": f"Пользователь {username} успешно зарегистрирован"

            }

        except ValueError as e:

            return {"success": False, "error": str(e)}

        except Exception as e:

            print(f"Неожиданная ошибка: {e}")

            return {"success": False, "error": "Произошла внутренняя ошибка"}

# Демонстрация

print("=== ДЕМОНСТРАЦИЯ БЕЗОПАСНОСТИ ===")

# Создаем безопасную форму

form = SafeWebForm()

# Обычная регистрация

print("1. Обычная регистрация:")

result = form.process_registration({

    'username': 'anna_2024',

    'email': 'anna@example.com',

    'age': '16'

})

print(result)

# Попытка атаки через имя пользователя

print("\n2. Попытка SQL инъекции:")

result = form.process_registration({

    'username': "'; DROP TABLE users; --",

    'email': 'hacker@evil.com',

    'age': '25'

})

print(result)

# Попытка XSS атаки

print("\n3. Попытка XSS атаки:")

result = form.process_registration({

    'username': '<script>alert("XSS")</script>',

    'email': 'xss@test.com',

    'age': '20'

})

print(result)

# Неверные данные

print("\n4. Неверные данные:")

result = form.process_registration({

    'username': 'ab',  # Слишком короткое

    'email': 'invalid-email',  # Неверный формат

    'age': '-5'  # Отрицательный возраст

})

print(result)

Криптография для начинающих

Криптография - это наука о защите информации с помощью математических методов.

Симметричное шифрование

from cryptography.fernet import Fernet

import base64

import os

class SimpleEncryption:

    """Простое симметричное шифрование"""

    def __init__(self):

        self.key = None

    def generate_key(self) -> bytes:

        """Генерация нового ключа"""

        self.key = Fernet.generate_key()

        return self.key

    def save_key(self, filename: str):

        """Сохранение ключа в файл"""

        if not self.key:

            raise ValueError("Ключ не сгенерирован")

        with open(filename, 'wb') as key_file:

            key_file.write(self.key)

        print(f"Ключ сохранен в файл {filename}")

    def load_key(self, filename: str):

        """Загрузка ключа из файла"""

        with open(filename, 'rb') as key_file:

            self.key = key_file.read()

        print(f"Ключ загружен из файла {filename}")

    def encrypt_message(self, message: str) -> str:

        """Шифрование сообщения"""

        if not self.key:

            raise ValueError("Ключ не установлен")

        f = Fernet(self.key)

        encrypted_message = f.encrypt(message.encode())

        # Кодируем в base64 для удобства отображения

        return base64.urlsafe_b64encode(encrypted_message).decode()

    def decrypt_message(self, encrypted_message: str) -> str:

        """Расшифрование сообщения"""

        if not self.key:

            raise ValueError("Ключ не установлен")

        f = Fernet(self.key)

        # Декодируем из base64

        encrypted_bytes = base64.urlsafe_b64decode(encrypted_message.encode())

        decrypted_message = f.decrypt(encrypted_bytes)

        return decrypted_message.decode()

    def encrypt_file(self, filename: str):

        """Шифрование файла"""

        if not self.key:

            raise ValueError("Ключ не установлен")

        f = Fernet(self.key)

        # Читаем файл

        with open(filename, 'rb') as file:

            file_data = file.read()

        # Шифруем данные

        encrypted_data = f.encrypt(file_data)

        # Сохраняем зашифрованный файл

        with open(filename + '.encrypted', 'wb') as encrypted_file:

            encrypted_file.write(encrypted_data)

        print(f"Файл {filename} зашифрован как {filename}.encrypted")

    def decrypt_file(self, encrypted_filename: str):

        """Расшифрование файла"""

        if not self.key:

            raise ValueError("Ключ не установлен")

        f = Fernet(self.key)

        # Читаем зашифрованный файл

        with open(encrypted_filename, 'rb') as encrypted_file:

            encrypted_data = encrypted_file.read()

        # Расшифровываем данные

        decrypted_data = f.decrypt(encrypted_data)

        # Сохраняем расшифрованный файл

        original_filename = encrypted_filename.replace('.encrypted', '')

        with open(original_filename + '.decrypted', 'wb') as decrypted_file:

            decrypted_file.write(decrypted_data)

        print(f"Файл {encrypted_filename} расшифрован как {original_filename}.decrypted")

# Демонстрация шифрования

print("=== ДЕМОНСТРАЦИЯ ШИФРОВАНИЯ ===")

encryptor = SimpleEncryption()

# Генерируем ключ

key = encryptor.generate_key()

print(f"Сгенерирован ключ: {base64.urlsafe_b64encode(key).decode()[:20]}...")

# Шифруем сообщение

secret_message = "Это секретное сообщение для программиста Анны!"

encrypted = encryptor.encrypt_message(secret_message)

print(f"Зашифрованное сообщение: {encrypted[:50]}...")

# Расшифровываем сообщение

decrypted = encryptor.decrypt_message(encrypted)

print(f"Расшифрованное сообщение: {decrypted}")

# Создаем тестовый файл и шифруем его

test_filename = "secret_diary.txt"

with open(test_filename, 'w', encoding='utf-8') as f:

    f.write("Сегодня я изучал криптографию. Это очень интересно!\nЯ научился шифровать файлы и сообщения.")

print(f"\nСоздан файл: {test_filename}")

encryptor.encrypt_file(test_filename)

# Сохраняем ключ для безопасности

encryptor.save_key("my_secret.key")

Хеширование и цифровые подписи

import hashlib

import hmac

import secrets

from datetime import datetime, timedelta

class HashingDemo:

    """Демонстрация хеширования и HMAC"""

    @staticmethod

    def simple_hash(message: str) -> str:

        """Простое хеширование SHA-256"""

        hash_object = hashlib.sha256(message.encode())

        return hash_object.hexdigest()

    @staticmethod

    def compare_hashes():

        """Демонстрация свойств хеш-функций"""

        print("=== СВОЙСТВА ХЕШ-ФУНКЦИЙ ===")

        messages = [

            "Привет, мир!",

            "Привет, мир!!",  # Добавили один символ

            "привет, мир!",   # Изменили регистр

            "",               # Пустая строка

            "A" * 1000        # Длинная строка

        ]

        for msg in messages:

            hash_value = HashingDemo.simple_hash(msg)

            print(f"'{msg[:20]}{'...' if len(msg) > 20 else ''}' -> {hash_value}")

    @staticmethod

    def password_hashing_demo():

        """Демонстрация безопасного хеширования паролей"""

        print("\n=== ХЕШИРОВАНИЕ ПАРОЛЕЙ ===")

        password = "MySecurePassword123!"

        # Плохо: простое хеширование

        simple_hash = hashlib.sha256(password.encode()).hexdigest()

        print(f"Простой хеш: {simple_hash}")

        # Хорошо: хеширование с солью

        salt = secrets.token_hex(16)

        salted_hash = hashlib.pbkdf2_hmac('sha256', 

                                        password.encode(), 

                                        salt.encode(), 

                                        100000)

        print(f"Соль: {salt}")

        print(f"Хеш с солью: {salted_hash.hex()}")

        # Проверка пароля

        def verify_password(password: str, salt: str, stored_hash: str) -> bool:

            hash_to_check = hashlib.pbkdf2_hmac('sha256',

                                              password.encode(),

                                              salt.encode(),

                                              100000)

            return hash_to_check.hex() == stored_hash

        # Тестируем проверку

        correct = verify_password("MySecurePassword123!", salt, salted_hash.hex())

        wrong = verify_password("WrongPassword", salt, salted_hash.hex())

        print(f"Правильный пароль: {correct}")

        print(f"Неправильный пароль: {wrong}")

    @staticmethod

    def hmac_demo():

        """Демонстрация HMAC для проверки целостности"""

        print("\n=== HMAC - ПРОВЕРКА ЦЕЛОСТНОСТИ ===")

        # Секретный ключ (должен храниться в безопасности)

        secret_key = secrets.token_bytes(32)

        # Сообщение

        message = "Важные данные: баланс счета = 1000000 рублей"

        # Создаем HMAC

        mac = hmac.new(secret_key, message.encode(), hashlib.sha256)

        signature = mac.hexdigest()

        print(f"Сообщение: {message}")

        print(f"HMAC подпись: {signature}")

        # Проверка целостности

        def verify_message(message: str, signature: str, key: bytes) -> bool:

            expected_mac = hmac.new(key, message.encode(), hashlib.sha256)

            return hmac.compare_digest(signature, expected_mac.hexdigest())

        # Тестируем

        original_valid = verify_message(message, signature, secret_key)

        tampered_valid = verify_message(message + " (изменено)", signature, secret_key)

        print(f"Оригинальное сообщение валидно: {original_valid}")

        print(f"Измененное сообщение валидно: {tampered_valid}")

class SimpleBlockchain:

    """Упрощенная демонстрация блокчейна"""

    def __init__(self):

        self.chain = []

        self.create_genesis_block()

    def create_genesis_block(self):

        """Создание первого блока"""

        genesis_block = {

            'index': 0,

            'timestamp': datetime.now().isoformat(),

            'data': 'Genesis Block',

            'previous_hash': '0',

            'hash': self.calculate_hash(0, datetime.now().isoformat(), 'Genesis Block', '0')

        }

        self.chain.append(genesis_block)

    def calculate_hash(self, index: int, timestamp: str, data: str, previous_hash: str) -> str:

        """Вычисление хеша блока"""

        block_string = f"{index}{timestamp}{data}{previous_hash}"

        return hashlib.sha256(block_string.encode()).hexdigest()

    def get_latest_block(self):

        """Получение последнего блока"""

        return self.chain[-1]

    def add_block(self, data: str):

        """Добавление нового блока"""

        previous_block = self.get_latest_block()

        new_index = previous_block['index'] + 1

        new_timestamp = datetime.now().isoformat()

        new_hash = self.calculate_hash(new_index, new_timestamp, data, previous_block['hash'])

        new_block = {

            'index': new_index,

            'timestamp': new_timestamp,

            'data': data,

            'previous_hash': previous_block['hash'],

            'hash': new_hash

        }

        self.chain.append(new_block)

        print(f"Блок {new_index} добавлен: {data}")

    def is_chain_valid(self) -> bool:

        """Проверка целостности цепочки"""

        for i in range(1, len(self.chain)):

            current_block = self.chain[i]

            previous_block = self.chain[i - 1]

            # Проверяем хеш текущего блока

            calculated_hash = self.calculate_hash(

                current_block['index'],

                current_block['timestamp'],

                current_block['data'],

                current_block['previous_hash']

            )

            if current_block['hash'] != calculated_hash:

                print(f"Блок {i} поврежден: неверный хеш")

                return False

            # Проверяем связь с предыдущим блоком

            if current_block['previous_hash'] != previous_block['hash']:

                print(f"Блок {i} поврежден: неверная связь с предыдущим блоком")

                return False

        return True

    def display_chain(self):

        """Отображение всей цепочки"""

        print("\n=== БЛОКЧЕЙН ===")

        for block in self.chain:

            print(f"Блок {block['index']}:")

            print(f"  Время: {block['timestamp']}")

            print(f"  Данные: {block['data']}")

            print(f"  Предыдущий хеш: {block['previous_hash'][:16]}...")

            print(f"  Хеш: {block['hash'][:16]}...")

            print()

# Демонстрация всех концепций

if __name__ == "__main__":

    # Хеширование

    HashingDemo.compare_hashes()

    HashingDemo.password_hashing_demo()

    HashingDemo.hmac_demo()

    # Простой блокчейн

    print("\n" + "="*50)

    blockchain = SimpleBlockchain()

    # Добавляем транзакции

    blockchain.add_block("Анна отправила 10 монет Ивану")

    blockchain.add_block("Иван отправил 5 монет Марии")

    blockchain.add_block("Мария отправила 2 монеты Петру")

    # Показываем цепочку

    blockchain.display_chain()

    # Проверяем целостность

    print(f"Цепочка валидна: {blockchain.is_chain_valid()}")

    # Попытка подделки

    print("\n=== ПОПЫТКА ПОДДЕЛКИ ===")

    blockchain.chain[1]['data'] = "Анна отправила 1000000 монет Ивану"  # Подделка!

    print(f"После подделки цепочка валидна: {blockchain.is_chain_valid()}")

Безопасность веб-приложений

Защита от основных уязвимостей

import re

import html

import urllib.parse

from typing import Dict, Any, List

import jwt

import secrets

from datetime import datetime, timedelta

class WebSecurityHelper:

    """Помощник для обеспечения безопасности веб-приложений"""

    def __init__(self, secret_key: str = None):

        self.secret_key = secret_key or secrets.token_urlsafe(32)

        self.blocked_patterns = [

            r'<script.*?>.*?</script>',  # XSS скрипты

            r'javascript:',              # JavaScript в ссылках

            r'on\w+\s*=',               # Event handlers

            r'<iframe.*?>',             # Встроенные фреймы

            r'<object.*?>',             # Объекты

            r'<embed.*?>',              # Встраивания

        ]

    def sanitize_html(self, user_input: str) -> str:

        """Защита от XSS атак"""

        if not isinstance(user_input, str):

            return ""

        # Экранируем HTML символы

        sanitized = html.escape(user_input)

        # Удаляем потенциально опасные паттерны

        for pattern in self.blocked_patterns:

            sanitized = re.sub(pattern, '', sanitized, flags=re.IGNORECASE)

        return sanitized.strip()

    def validate_and_sanitize_form(self, form_data: Dict[str, Any]) -> Dict[str, Any]:

        """Комплексная проверка и очистка формы"""

        sanitized_data = {}

        errors = []

        for field_name, value in form_data.items():

            if isinstance(value, str):

                # Очищаем от XSS

                clean_value = self.sanitize_html(value)

                # Дополнительные проверки для специфических полей

                if field_name == 'email':

                    if not self._is_valid_email(clean_value):

                        errors.append(f"Неверный формат email: {field_name}")

                        continue

                elif field_name == 'url':

                    if not self._is_safe_url(clean_value):

                        errors.append(f"Небезопасный URL: {field_name}")

                        continue

                elif field_name in ['password', 'confirm_password']:

                    # Пароли не санитизируем, но проверяем сложность

                    if not self._is_strong_password(value):  # Используем оригинальное значение

                        errors.append(f"Слабый пароль: {field_name}")

                        continue

                    clean_value = value  # Оставляем оригинальный пароль

                sanitized_data[field_name] = clean_value

            else:

                sanitized_data[field_name] = value

        return {

            'data': sanitized_data,

            'errors': errors,

            'is_valid': len(errors) == 0

        }

    def _is_valid_email(self, email: str) -> bool:

        """Проверка email адреса"""

        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

        return bool(re.match(pattern, email)) and len(email) <= 254

    def _is_safe_url(self, url: str) -> bool:

        """Проверка безопасности URL"""

        try:

            parsed = urllib.parse.urlparse(url)

            # Разрешаем только HTTP и HTTPS

            if parsed.scheme not in ['http', 'https', '']:

                return False

            # Блокируем локальные адреса для предотвращения SSRF

            if parsed.hostname in ['localhost', '127.0.0.1', '0.0.0.0']:

                return False

            return True

        except:

            return False

    def _is_strong_password(self, password: str) -> bool:

        """Проверка надежности пароля"""

        if len(password) < 8:

            return False

        checks = [

            any(c.isupper() for c in password),  # Заглавные буквы

            any(c.islower() for c in password),  # Строчные буквы

            any(c.isdigit() for c in password),  # Цифры

            any(c in "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password)  # Спецсимволы

        ]

        return sum(checks) >= 3

    def generate_csrf_token(self, user_id: str) -> str:

        """Генерация CSRF токена"""

        payload = {

            'user_id': user_id,

            'timestamp': datetime.utcnow().timestamp(),

            'csrf': secrets.token_urlsafe(16)

        }

        return jwt.encode(payload, self.secret_key, algorithm='HS256')

    def validate_csrf_token(self, token: str, user_id: str) -> bool:

        """Проверка CSRF токена"""

        try:

            payload = jwt.decode(token, self.secret_key, algorithms=['HS256'])

            # Проверяем пользователя

            if payload.get('user_id') != user_id:

                return False

            # Проверяем время жизни токена (1 час)

            token_time = datetime.fromtimestamp(payload.get('timestamp', 0))

            if datetime.utcnow() - token_time > timedelta(hours=1):

                return False

            return True

        except jwt.InvalidTokenError:

            return False

    def create_secure_session(self, user_id: str, user_data: Dict[str, Any]) -> str:

        """Создание безопасной сессии"""

        payload = {

            'user_id': user_id,

            'user_data': user_data,

            'created_at': datetime.utcnow().timestamp(),

            'expires_at': (datetime.utcnow() + timedelta(hours=24)).timestamp(),

            'session_id': secrets.token_urlsafe(16)

        }

        return jwt.encode(payload, self.secret_key, algorithm='HS256')

    def validate_session(self, session_token: str) -> Dict[str, Any]:

        """Проверка сессии"""

        try:

            payload = jwt.decode(session_token, self.secret_key, algorithms=['HS256'])

            # Проверяем время жизни

            expires_at = datetime.fromtimestamp(payload.get('expires_at', 0))

            if datetime.utcnow() > expires_at:

                return {'valid': False, 'error': 'Session expired'}

            return {

                'valid': True,

                'user_id': payload.get('user_id'),

                'user_data': payload.get('user_data', {}),

                'session_id': payload.get('session_id')

            }

        except jwt.InvalidTokenError as e:

            return {'valid': False, 'error': str(e)}

class SecureWebApp:

    """Пример безопасного веб-приложения"""

    def __init__(self):

        self.security = WebSecurityHelper()

        self.users = {}  # В реальности - база данных

        self.active_sessions = {}

    def register_user(self, form_data: Dict[str, Any], ip_address: str) -> Dict[str, Any]:

        """Безопасная регистрация пользователя"""

        # Проверяем и очищаем данные формы

        validation_result = self.security.validate_and_sanitize_form(form_data)

        if not validation_result['is_valid']:

            return {

                'success': False,

                'errors': validation_result['errors']

            }

        clean_data = validation_result['data']

        # Проверяем, что пользователь не существует

        username = clean_data.get('username')

        email = clean_data.get('email')

        if username in self.users:

            return {

                'success': False,

                'errors': ['Пользователь с таким именем уже существует']

            }

        # Проверяем совпадение паролей

        if clean_data.get('password') != clean_data.get('confirm_password'):

            return {

                'success': False,

                'errors': ['Пароли не совпадают']

            }

        # Хешируем пароль

        password_hash, salt = self._hash_password(clean_data['password'])

        # Сохраняем пользователя

        self.users[username] = {

            'username': username,

            'email': email,

            'password_hash': password_hash,

            'salt': salt,

            'created_at': datetime.utcnow().isoformat(),

            'last_login_ip': ip_address

        }

        return {

            'success': True,

            'message': f'Пользователь {username} успешно зарегистрирован'

        }

    def login_user(self, username: str, password: str, ip_address: str) -> Dict[str, Any]:

        """Безопасный вход в систему"""

        # Очищаем входные данные

        username = self.security.sanitize_html(username)

        if username not in self.users:

            return {

                'success': False,

                'error': 'Неверные учетные данные'

            }

        user = self.users[username]

        # Проверяем пароль

        if not self._verify_password(password, user['password_hash'], user['salt']):

            return {

                'success': False,

                'error': 'Неверные учетные данные'

            }

        # Создаем сессию

        session_token = self.security.create_secure_session(

            username,

            {

                'email': user['email'],

                'last_login': datetime.utcnow().isoformat()

            }

        )

        # Генерируем CSRF токен

        csrf_token = self.security.generate_csrf_token(username)

        # Обновляем информацию о входе

        user['last_login_ip'] = ip_address

        user['last_login'] = datetime.utcnow().isoformat()

        return {

            'success': True,

            'session_token': session_token,

            'csrf_token': csrf_token,

            'user_info': {

                'username': username,

                'email': user['email']

            }

        }

    def protected_action(self, session_token: str, csrf_token: str, action_data: Dict[str, Any]) -> Dict[str, Any]:

        """Пример защищенного действия"""

        # Проверяем сессию

        session_validation = self.security.validate_session(session_token)

        if not session_validation['valid']:

            return {

                'success': False,

                'error': 'Недействительная сессия: ' + session_validation.get('error', 'Unknown error')

            }

        user_id = session_validation['user_id']

        # Проверяем CSRF токен

        if not self.security.validate_csrf_token(csrf_token, user_id):

            return {

                'success': False,

                'error': 'Недействительный CSRF токен'

            }

        # Очищаем данные действия

        validation_result = self.security.validate_and_sanitize_form(action_data)

        if not validation_result['is_valid']:

            return {

                'success': False,

                'errors': validation_result['errors']

            }

        clean_data = validation_result['data']

        # Выполняем защищенное действие

        return {

            'success': True,

            'message': f'Действие выполнено для пользователя {user_id}',

            'processed_data': clean_data

        }

    def _hash_password(self, password: str) -> tuple:

        """Хеширование пароля с солью"""

        salt = secrets.token_hex(16)

        password_hash = hashlib.pbkdf2_hmac('sha256', 

                                          password.encode(), 

                                          salt.encode(), 

                                          100000)

        return password_hash.hex(), salt

    def _verify_password(self, password: str, stored_hash: str, salt: str) -> bool:

        """Проверка пароля"""

        password_hash = hashlib.pbkdf2_hmac('sha256',

                                          password.encode(),

                                          salt.encode(),

                                          100000)

        return secrets.compare_digest(password_hash.hex(), stored_hash)

# Демонстрация безопасного веб-приложения

if __name__ == "__main__":

    print("=== ДЕМОНСТРАЦИЯ БЕЗОПАСНОГО ВЕБ-ПРИЛОЖЕНИЯ ===")

    app = SecureWebApp()

    # Регистрация пользователя

    print("1. Регистрация пользователя:")

    registration_data = {

        'username': 'anna_secure',

        'email': 'anna@example.com',

        'password': 'MySecure123!',

        'confirm_password': 'MySecure123!'

    }

    result = app.register_user(registration_data, '192.168.1.100')

    print(result)

    # Попытка XSS атаки при регистрации

    print("\n2. Попытка XSS атаки:")

    xss_data = {

        'username': '<script>alert("XSS")</script>hacker',

        'email': 'hacker@evil.com',

        'password': 'HackPass123!',

        'confirm_password': 'HackPass123!'

    }

    result = app.register_user(xss_data, '192.168.1.101')

    print(result)

    # Вход в систему

    print("\n3. Вход в систему:")

    login_result = app.login_user('anna_secure', 'MySecure123!', '192.168.1.100')

    print(f"Успех: {login_result['success']}")

    if login_result['success']:

        session_token = login_result['session_token']

        csrf_token = login_result['csrf_token']

        # Выполнение защищенного действия

        print("\n4. Защищенное действие:")

        action_data = {

            'action': 'update_profile',

            'new_email': 'anna.new@example.com'

        }

        result = app.protected_action(session_token, csrf_token, action_data)

        print(result)

        # Попытка CSRF атаки

        print("\n5. Попытка CSRF атаки (неверный токен):")

        result = app.protected_action(session_token, 'fake_csrf_token', action_data)

        print(result)

Практические советы по безопасности

Чек-лист безопасности для начинающих программистов

class SecurityChecklist:

    """Чек-лист безопасности для разработчиков"""

    @staticmethod

    def check_password_security():

        """Проверка безопасности паролей"""

        print("=== ЧЕК-ЛИСТ: БЕЗОПАСНОСТЬ ПАРОЛЕЙ ===")

        checklist = [

            "✓ Минимум 8 символов",

            "✓ Сочетание заглавных и строчных букв",

            "✓ Цифры и специальные символы",

            "✓ Не содержит личную информацию",

            "✓ Уникальный для каждого сервиса",

            "✓ Хранится в зашифрованном виде",

            "✓ Регулярно меняется (раз в 3-6 месяцев)"

        ]

        for item in checklist:

            print(item)

    @staticmethod

    def check_code_security():

        """Проверка безопасности кода"""

        print("\n=== ЧЕК-ЛИСТ: БЕЗОПАСНОСТЬ КОДА ===")

        checklist = [

            "✓ Всегда проверяем пользовательский ввод",

            "✓ Используем параметризованные SQL запросы",

            "✓ Экранируем HTML вывод",

            "✓ Проверяем права доступа",

            "✓ Логируем важные события",

            "✓ Используем HTTPS для передачи данных",

            "✓ Не храним пароли в открытом виде",

            "✓ Обновляем зависимости и библиотеки",

            "✓ Проводим код-ревью",

            "✓ Тестируем на уязвимости"

        ]

        for item in checklist:

            print(item)

    @staticmethod

    def check_personal_security():

        """Проверка личной безопасности"""

        print("\n=== ЧЕК-ЛИСТ: ЛИЧНАЯ БЕЗОПАСНОСТЬ ===")

        checklist = [

            "✓ Используем менеджер паролей",

            "✓ Включена двухфакторная аутентификация",

            "✓ Регулярно обновляем операционную систему",

            "✓ Используем антивирус",

            "✓ Проверяем настройки приватности в соцсетях",

            "✓ Не публикуем личную информацию",

            "✓ Осторожны с общественным Wi-Fi",

            "✓ Делаем резервные копии важных данных",

            "✓ Не переходим по подозрительным ссылкам",

            "✓ Проверяем банковские выписки"

        ]

        for item in checklist:

            print(item)

class SecurityAwareness:

    """Повышение осведомленности о безопасности"""

    @staticmethod

    def common_attack_scenarios():

        """Распространенные сценарии атак"""

        print("=== РАСПРОСТРАНЕННЫЕ АТАКИ ===")

        scenarios = {

            "Фишинг": {

                "описание": "Поддельные письма или сайты для кражи данных",

                "пример": "Письмо 'от банка' с просьбой ввести пароль",

                "защита": "Проверяйте адрес отправителя и URL сайта"

            },

            "Социальная инженерия": {

                "описание": "Психологическое воздействие для получения информации",

                "пример": "Звонок 'от техподдержки' с просьбой назвать пароль",

                "защита": "Никогда не сообщайте пароли по телефону"

            },

            "Вредоносное ПО": {

                "описание": "Программы, наносящие вред компьютеру",

                "пример": "Троян, маскирующийся под игру",

                "защита": "Скачивайте программы только с официальных сайтов"

            },

            "Перехват трафика": {

                "описание": "Прослушивание сетевого трафика",

                "пример": "Перехват данных в открытом Wi-Fi",

                "защита": "Используйте VPN в общественных сетях"

            }

        }

        for attack, info in scenarios.items():

            print(f"\n{attack}:")

            print(f"  Описание: {info['описание']}")

            print(f"  Пример: {info['пример']}")

            print(f"  Защита: {info['защита']}")

    @staticmethod

    def security_tools_for_beginners():

        """Инструменты безопасности для начинающих"""

        print("\n=== ПОЛЕЗНЫЕ ИНСТРУМЕНТЫ ===")

        tools = {

            "Менеджеры паролей": [

                "Bitwarden (бесплатный)",

                "1Password",

                "LastPass",

                "KeePass"

            ],

            "Двухфакторная аутентификация": [

                "Google Authenticator",

                "Authy",

                "Microsoft Authenticator"

            ],

            "Проверка безопасности сайтов": [

                "VirusTotal",

                "URLVoid",

                "Google Safe Browsing"

            ],

            "Анонимность и приватность": [

                "Tor Browser",

                "VPN сервисы",

                "DuckDuckGo (поисковик)"

            ],

            "Проверка утечек данных": [

                "Have I Been Pwned",

                "DeHashed",

                "LeakCheck"

            ]

        }

        for category, tool_list in tools.items():

            print(f"\n{category}:")

            for tool in tool_list:

                print(f"  • {tool}")

# Демонстрация образовательных материалов

if __name__ == "__main__":

    SecurityChecklist.check_password_security()

    SecurityChecklist.check_code_security() 

    SecurityChecklist.check_personal_security()

    SecurityAwareness.common_attack_scenarios()

    SecurityAwareness.security_tools_for_beginners()

Заключение

Кибербезопасность - это не просто набор технических мер, а образ мышления, который должен сопровождать каждого программиста на протяжении всей карьеры. В современном мире, где цифровые технологии проникают во все сферы жизни, ответственность за безопасность лежит на каждом из нас.

Ключевые принципы безопасности для юных программистов:

1. Безопасность с самого начала - думайте о защите на этапе проектирования

2. Никогда не доверяйте пользовательскому вводу - всегда проверяйте и санитизируйте данные

3. Принцип минимальных привилегий - давайте только необходимые права доступа

4. Защита в глубину - используйте несколько уровней защиты

5. Регулярное обучение - следите за новыми угрозами и методами защиты

Помните:

• Хакеры не спят - они постоянно ищут новые способы атак

• Одна небольшая уязвимость может привести к серьезным последствиям

• Безопасность - это процесс, а не результат

• Лучше перестраховаться, чем потом исправлять последствия

Следующие шаги в изучении кибербезопасности:

• Изучите OWASP Top 10 (основные веб-уязвимости)

• Попробуйте этичный хакинг на платформах типа HackTheBox

• Изучите криптографию более глубоко

• Участвуйте в CTF соревнованиях

• Следите за новостями информационной безопасности

Кибербезопасность - это не препятствие для разработки, а инструмент создания надежных и качественных продуктов. Пользователи доверяют нам свои данные, и наша задача - оправдать это доверие.

Безопасный код - это хороший код. Программируйте ответственно! 🔒✨