Вопросы для собеседования на должность младшего инженера по безопасности: Полное руководство

# Уязвимый код
username = request.GET['username']
query = f"SELECT * FROM users WHERE username = '{username}'"
# Атака: username = "admin' OR '1'='1"

# Безопасный код (параметризованный запрос)
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))

# Уязвимо: Нет проверки авторизации
@app.route('/admin/users/<user_id>')
def get_user(user_id):
    return User.query.get(user_id)

# Безопасно: Проверка авторизации
@app.route('/admin/users/<user_id>')
@require_admin
def get_user(user_id):
    if not current_user.is_admin:
        abort(403)
    return User.query.get(user_id)

<!-- Уязвимо -->
<div>Добро пожаловать, {{ username }}</div>

<!-- Атака -->
username = "<script>alert('XSS')</script>"

<!-- Безопасно (экранирование вывода) -->
<div>Добро пожаловать, {{ username | escape }}</div>

# Сканирование уязвимостей с помощью Nmap
nmap --script vuln 192.168.1.100

# Сканирование OpenVAS
openvas-start
# Доступ к веб-интерфейсу по адресу https://localhost:9392

# Сканирование Nessus (коммерческий)
# Настройка через веб-интерфейс

# Автоматизация сканирования Nessus
import requests
import time

class NessusScanner:
    def __init__(self, url, access_key, secret_key):
        self.url = url
        self.headers = {
            'X-ApiKeys': f'accessKey={access_key}; secretKey={secret_key}'
        }
    
    def create_scan(self, name, targets):
        data = {
            'uuid': 'template-uuid',  # Basic Network Scan
            'settings': {
                'name': name,
                'text_targets': targets
            }
        }
        response = requests.post(
            f'{self.url}/scans',
            headers=self.headers,
            json=data,
            verify=False
        )
        return response.json()['scan']['id']
    
    def launch_scan(self, scan_id):
        requests.post(
            f'{self.url}/scans/{scan_id}/launch',
            headers=self.headers,
            verify=False
        )
    
    def get_results(self, scan_id):
        response = requests.get(
            f'{self.url}/scans/{scan_id}',
            headers=self.headers,
            verify=False
        )
        return response.json()

# Использование
scanner = NessusScanner('https://nessus:8834', 'access_key', 'secret_key')
scan_id = scanner.create_scan('Еженедельное сканирование', '192.168.1.0/24')
scanner.launch_scan(scan_id)

# Управление исправлениями Linux
# Ubuntu/Debian
sudo apt update
sudo apt list --upgradable
sudo apt upgrade -y

# CentOS/RHEL
sudo yum check-update
sudo yum update -y

# Автоматическое применение исправлений
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

# Отслеживание уязвимостей
class VulnerabilityTracker:
    def __init__(self):
        self.vulnerabilities = []
    
    def add_vulnerability(self, vuln):
        self.vulnerabilities.append({
            'id': vuln['id'],
            'severity': vuln['severity'],
            'asset': vuln['asset'],
            'status': 'open',
            'discovered': datetime.now(),
            'sla_deadline': self.calculate_sla(vuln['severity'])
        })
    
    def calculate_sla(self, severity):
        sla_days = {
            'critical': 7,
            'high': 30,
            'medium': 90,
            'low': 180
        }
        return datetime.now() + timedelta(days=sla_days[severity])
    
    def get_overdue(self):
        return [v for v in self.vulnerabilities 
                if v['status'] == 'open' and 
                datetime.now() > v['sla_deadline']]

# Симметричное шифрование (AES)
from cryptography.fernet import Fernet

# Генерация ключа
key = Fernet.generate_key()
cipher = Fernet(key)

# Шифрование
encrypted = cipher.encrypt(b"Secret message")

# Дешифрование
decrypted = cipher.decrypt(encrypted)

# Асимметричное шифрование (RSA)
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# Генерация пары ключей
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Шифрование открытым ключом, дешифрование закрытым ключом

# Просмотр деталей сертификата
openssl x509 -in certificate.crt -text -noout

# Сертификат содержит:
# - Subject (имя домена)
# - Issuer (CA)
# - Срок действия
# - Открытый ключ
# - Подпись

# Генерация закрытого ключа
openssl genrsa -out private.key 2048

# Генерация CSR
openssl req -new -key private.key -out request.csr

# Просмотр CSR
openssl req -text -noout -verify -in request.csr

# Генерация самоподписанного сертификата
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

# Объединение для использования на сервере
cat cert.pem key.pem > server.pem

# Nginx
server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
}

# Apache
<VirtualHost *:443>
    ServerName example.com
    
    SSLEngine on
    SSLCertificateFile /etc/apache2/ssl/cert.pem
    SSLCertificateKeyFile /etc/apache2/ssl/key.pem
    SSLCertificateChainFile /etc/apache2/ssl/chain.pem
    
    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
    SSLCipherSuite HIGH:!aNULL:!MD5
</VirtualHost>

# Плохо: Разрешает SSLv3, TLSv1.0
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;

# Хорошо: Только современные TLS
ssl_protocols TLSv1.2 TLSv1.3;

# Проверка конфигурации SSL
sslscan example.com
nmap --script ssl-enum-ciphers -p 443 example.com

# Или используйте онлайн инструменты
# https://www.ssllabs.com/ssltest/

# Проверка срока действия сертификата
openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null | \
    openssl x509 -noout -dates

# Мониторинг срока действия
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | \
    openssl x509 -noout -enddate

# Установка certbot
sudo apt install certbot python3-certbot-nginx

# Получение сертификата
sudo certbot --nginx -d example.com -d www.example.com

# Автоматическое обновление (cron)
0 0 * * * certbot renew --quiet

# Тестирование TLS соединения
openssl s_client -connect example.com:443 -servername example.com

# Проверка цепочки сертификатов
openssl verify -CAfile ca-bundle.crt certificate.crt

# Проверка соответствия сертификата закрытому ключу
openssl x509 -noout -modulus -in cert.pem | openssl md5
openssl rsa -noout -modulus -in key.pem | openssl md5
# Хеши должны совпадать

# iptables (stateful)
# Разрешить установленные соединения
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Разрешить новые SSH соединения
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT

# Отбросить все остальное
iptables -A INPUT -j DROP

# Установка Snort
sudo apt install snort

# Настройка сети
sudo vi /etc/snort/snort.conf
# Установка HOME_NET
ipvar HOME_NET 192.168.1.0/24
ipvar EXTERNAL_NET !$HOME_NET

# Запуск в режиме IDS
sudo snort -A console -q -c /etc/snort/snort.conf -i eth0

# Запуск в режиме IPS (встроенный)
sudo snort -Q -c /etc/snort/snort.conf -i eth0

# Синтаксис правила
# action protocol src_ip src_port -> dst_ip dst_port (options)

# Обнаружение SQL injection
alert tcp any any -> $HOME_NET 80 (msg:"SQL Injection Attempt"; \
    content:"UNION SELECT"; nocase; sid:1000001; rev:1;)

# Обнаружение сканирования портов
alert tcp any any -> $HOME_NET any (msg:"Port Scan Detected"; \
    flags:S; threshold:type both, track by_src, count 20, seconds 60; \
    sid:1000002; rev:1;)

# Обнаружение атак перебором SSH
alert tcp any any -> $HOME_NET 22 (msg:"SSH Brute Force"; \
    flags:S; threshold:type both, track by_src, count 5, seconds 60; \
    sid:1000003; rev:1;)

# Блокировка вредоносного IP (режим IPS)
drop tcp 203.0.113.50 any -> $HOME_NET any (msg:"Blocked Malicious IP"; \
    sid:1000004; rev:1;)

# Установка Suricata
sudo apt install suricata

# Обновление правил
sudo suricata-update

# Запуск Suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0

# Просмотр оповещений
sudo tail -f /var/log/suricata/fast.log

# Анализ оповещений Snort
import re
from collections import Counter

def analyze_snort_alerts(log_file):
    alerts = []
    
    with open(log_file, 'r') as f:
        for line in f:
            # Parse alert
            match = re.search(r'\[\*\*\] \[(\d+):(\d+):(\d+)\] (.+?) \[\*\*\]', line)
            if match:
                alerts.append({
                    'sid': match.group(1),
                    'message': match.group(4),
                    'line': line
                })
    
    # Top alerts
    alert_counts = Counter([a['message'] for a in alerts])
    print("Топ 10 оповещений:")
    for alert, count in alert_counts.most_common(10):
        print(f"{count:5d} - {alert}")
    
    return alerts

# Использование
alerts = analyze_snort_alerts('/var/log/snort/alert')

# SQL Injection
content:"' OR 1=1--";
content:"UNION SELECT";

# XSS
content:"<script>";
content:"javascript:";

# Command Injection
content:";cat /etc/passwd";
content:"|whoami";

# Directory Traversal
content:"../../../";

# Shellshock
content:"() { :; };";

import hashlib
import os

def hash_password(password):
    # Генерация соли
    salt = os.urandom(32)
    
    # Хеширование пароля с солью
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # iterations
    )
    
    # Хранение соли + хеша
    return salt + key

def verify_password(stored_password, provided_password):
    salt = stored_password[:32]
    stored_key = stored_password[32:]
    
    key = hashlib.pbkdf2_hmac(
        'sha256',
        provided_password.encode('utf-8'),
        salt,
        100000
    )
    
    return key == stored_key