// practical snippets

Code Examples

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

read-onlylocal-firstdefensiveredacted evidencecontrolled lab

// why code

Не только теория

Каждый пример показывает маленький проверяемый кусок логики, а не абстрактное описание. Опасные классы кода не публикуются: credential abuse, keylogging, C2, destructive payloads. Формат подходит для лабораторных стендов, личных заметок и defensive-checklist.

// snippets

Учебные фрагменты

foundations Web/API

HTTP security headers checker

Минимальный read-only чекер security headers для собственного сайта или лабораторного стенда.

Safety boundary: Принимает один URL, не делает crawling, не отправляет payload и не меняет состояние.

from urllib.parse import urlparse
import requests

REQUIRED_HEADERS = {
    "strict-transport-security": "HSTS снижает риск downgrade на HTTP",
    "content-security-policy": "CSP ограничивает выполнение чужого кода",
    "x-frame-options": "защита от clickjacking для старых клиентов",
    "referrer-policy": "меньше утечек URL через Referer",
}


def check_headers(url: str) -> dict[str, str]:
    parsed = urlparse(url)
    if parsed.scheme not in {"https", "http"} or not parsed.netloc:
        raise ValueError("Передайте полный URL: https://example.com")

    response = requests.get(url, timeout=8, allow_redirects=True)
    headers = {k.lower(): v for k, v in response.headers.items()}

    return {
        name: "ok" if name in headers else f"missing: {reason}"
        for name, reason in REQUIRED_HEADERS.items()
    }


if __name__ == "__main__":
    for header, status in check_headers("https://example.com").items():
        print(f"{header}: {status}")

foundations Network

DNS inventory snapshot

Собирает базовую карту DNS-записей домена для инвентаризации периметра.

Safety boundary: Только DNS-запросы к публичным резолверам; не сканирует IP и не трогает сервисы.

import dns.resolver

RECORD_TYPES = ["A", "AAAA", "MX", "TXT", "NS", "CAA"]


def resolve_domain(domain: str) -> dict[str, list[str]]:
    resolver = dns.resolver.Resolver()
    resolver.lifetime = 4
    result: dict[str, list[str]] = {}

    for record_type in RECORD_TYPES:
        try:
            answers = resolver.resolve(domain, record_type)
            result[record_type] = sorted(str(answer).strip() for answer in answers)
        except Exception as exc:
            result[record_type] = [f"not available: {exc.__class__.__name__}"]

    return result


for rtype, values in resolve_domain("example.com").items():
    print(f"[{rtype}]")
    for value in values:
        print(" ", value)

foundations Cryptography

Hash shape identifier

Учебный классификатор формы хэша: помогает отличить encoding от hash и не путать это с шифрованием.

Safety boundary: Не взламывает хэши и не делает brute force; только проверяет длину и алфавит.

import re

PATTERNS = {
    "md5-like": re.compile(r"^[a-f0-9]{32}$", re.I),
    "sha1-like": re.compile(r"^[a-f0-9]{40}$", re.I),
    "sha256-like": re.compile(r"^[a-f0-9]{64}$", re.I),
    "bcrypt-like": re.compile(r"^\$2[aby]\$\d{2}\$.{53}$"),
    "argon2-like": re.compile(r"^\$argon2(id|i|d)\$"),
}


def identify(value: str) -> list[str]:
    value = value.strip()
    matches = [name for name, pattern in PATTERNS.items() if pattern.match(value)]
    return matches or ["unknown"]


samples = [
    "5d41402abc4b2a76b9719d911017c592",
    "$argon2id$v=19$m=65536,t=3,p=4$...",
]

for sample in samples:
    print(sample, "=>", ", ".join(identify(sample)))

beginner Network

Allowlisted service inventory

Показывает, как проверять только заранее разрешённые host:port пары, не превращая пример в массовый сканер.

Safety boundary: Нет диапазонов, нет многопоточности, нет fingerprinting; только allowlist владельца стенда.

import socket
from dataclasses import dataclass


@dataclass(frozen=True)
class Service:
    host: str
    port: int
    expected: str


ALLOWLIST = [
    Service("127.0.0.1", 22, "ssh"),
    Service("127.0.0.1", 443, "https"),
]


def is_open(service: Service, timeout: float = 1.0) -> bool:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.settimeout(timeout)
        return sock.connect_ex((service.host, service.port)) == 0


for service in ALLOWLIST:
    status = "open" if is_open(service) else "closed"
    print(f"{service.host}:{service.port} {service.expected} => {status}")

beginner Privacy

Metadata report for local files

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

Safety boundary: Работает только с локальной папкой, ничего не отправляет наружу и не удаляет оригиналы.

from pathlib import Path
from PIL import Image


def image_metadata(path: Path) -> dict[str, str]:
    with Image.open(path) as img:
        return {
            "format": img.format or "unknown",
            "size": f"{img.width}x{img.height}",
            "exif_fields": str(len(img.getexif())),
        }


for file_path in Path("publish-candidates").glob("*"):
    if file_path.suffix.lower() not in {".jpg", ".jpeg", ".png", ".webp"}:
        continue
    try:
        print(file_path.name, image_metadata(file_path))
    except Exception as exc:
        print(file_path.name, "metadata read failed:", exc)

intermediate Secrets

Secrets redactor before evidence sharing

Минимальный redaction-слой для логов и evidence перед отправкой в отчёт.

Safety boundary: Не валидирует токены и не отправляет их в сторонние сервисы; только маскирует похожие значения.

import re

RULES = [
    (re.compile(r"AKIA[0-9A-Z]{16}"), "AWS_ACCESS_KEY"),
    (re.compile(r"gh[pousr]_[A-Za-z0-9_]{20,}"), "GITHUB_TOKEN"),
    (re.compile(r"(?i)(password|passwd|pwd)\s*[=:]\s*\S+"), "PASSWORD_FIELD"),
    (re.compile(r"(?i)(authorization:\s*bearer\s+)[A-Za-z0-9._-]+"), "BEARER_TOKEN"),
]


def redact(text: str) -> str:
    for pattern, label in RULES:
        text = pattern.sub(f"[REDACTED:{label}]", text)
    return text


raw_log = "Authorization: Bearer eyJhbGciOi... password=not-for-report"
print(redact(raw_log))

intermediate Cloud/Container

Docker Compose risk hints

Проверяет compose-файл на несколько частых risky-настроек.

Safety boundary: Статический анализ локального YAML; контейнеры не запускаются и не меняются.

from pathlib import Path
import yaml


def audit_compose(path: Path) -> list[str]:
    doc = yaml.safe_load(path.read_text()) or {}
    findings: list[str] = []

    for name, service in (doc.get("services") or {}).items():
        if service.get("privileged") is True:
            findings.append(f"{name}: privileged=true")
        if service.get("user") in (None, "", "0", "root"):
            findings.append(f"{name}: container may run as root")
        for volume in service.get("volumes") or []:
            if "/var/run/docker.sock" in str(volume):
                findings.append(f"{name}: docker.sock mounted")
        if service.get("network_mode") == "host":
            findings.append(f"{name}: host network mode")

    return findings


for finding in audit_compose(Path("compose.yml")):
    print("risk:", finding)

intermediate Supply Chain

SBOM package matcher

Учебный пример сопоставления SBOM-компонентов с локальным списком известных рисков.

Safety boundary: Использует локальный пример базы уязвимостей; не делает сетевых запросов и не меняет проект.

import json
from pathlib import Path

KNOWN_RISKS = {
    ("openssl", "1.0.1"): "outdated crypto library",
    ("log4j-core", "2.14.1"): "critical historical risk, upgrade required",
}


def load_components(path: Path) -> list[tuple[str, str]]:
    sbom = json.loads(path.read_text())
    components = sbom.get("components", [])
    return [(item.get("name", ""), item.get("version", "")) for item in components]


for name, version in load_components(Path("sbom.cdx.json")):
    risk = KNOWN_RISKS.get((name, version))
    if risk:
        print(f"{name}@{version}: {risk}")

intermediate Web/API

OpenAPI sensitive flow inventory

Извлекает из OpenAPI endpoints, которые обычно требуют ручной проверки авторизации и бизнес-логики.

Safety boundary: Только парсинг спецификации; не отправляет HTTP-запросы.

import json
from pathlib import Path

KEYWORDS = {
    "auth": ["login", "token", "session"],
    "account": ["user", "profile", "account"],
    "billing": ["invoice", "payment", "subscription"],
    "upload": ["upload", "file", "avatar"],
    "admin": ["admin", "role", "permission"],
}


def classify(path: str) -> list[str]:
    low = path.lower()
    return [label for label, words in KEYWORDS.items() if any(word in low for word in words)]


spec = json.loads(Path("openapi.json").read_text())
for path, methods in spec.get("paths", {}).items():
    labels = classify(path)
    if labels:
        print(path, "=>", ", ".join(labels), "methods:", ", ".join(methods.keys()))

intermediate SOC

Auth log summary for SIEM triage

Сжимает auth-логи в понятную таблицу источников ошибок входа.

Safety boundary: Читает локальный лог-файл и не публикует raw usernames; показывает агрегаты.

from collections import Counter
from pathlib import Path
import re

FAILED = re.compile(r"Failed password .* from (?P<ip>\d+\.\d+\.\d+\.\d+)")


def summarize_failed_logins(path: Path) -> Counter[str]:
    counter: Counter[str] = Counter()
    for line in path.read_text(errors="ignore").splitlines():
        match = FAILED.search(line)
        if match:
            counter[match.group("ip")] += 1
    return counter


for ip, count in summarize_failed_logins(Path("auth.log")).most_common(10):
    print(f"{ip}: {count} failed attempts")

advanced Monitoring

Service health check with clear output

Пример маленького health-check скрипта для uptime/incident monitoring.

Safety boundary: Проверяет только явно заданные URL, не сканирует сайт и не обходит авторизацию.

import time
import requests

TARGETS = {
    "main_site": "https://example.com/",
    "status_page": "https://example.com/status",
}


def check(name: str, url: str) -> str:
    started = time.perf_counter()
    try:
        response = requests.get(url, timeout=5)
        latency_ms = int((time.perf_counter() - started) * 1000)
        return f"{name}: HTTP {response.status_code}, {latency_ms} ms"
    except requests.RequestException as exc:
        return f"{name}: DOWN, {exc.__class__.__name__}"


for name, url in TARGETS.items():
    print(check(name, url))

advanced Threat Detection

Access-log feature extraction

Показывает, какие признаки можно извлечь из access-log перед rule/ML triage.

Safety boundary: Не делает выводов об атаке сам по себе; только готовит признаки для аналитика.

from dataclasses import dataclass
from urllib.parse import urlparse, parse_qs


@dataclass
class HttpFeatures:
    path_depth: int
    query_keys: int
    has_encoded_chars: bool
    looks_like_admin_path: bool


def extract_features(url: str) -> HttpFeatures:
    parsed = urlparse(url)
    path_parts = [part for part in parsed.path.split("/") if part]
    query = parse_qs(parsed.query, keep_blank_values=True)
    return HttpFeatures(
        path_depth=len(path_parts),
        query_keys=len(query),
        has_encoded_chars="%" in url,
        looks_like_admin_path=any(part in {"admin", "manage", "debug"} for part in path_parts),
    )


print(extract_features("/account/profile?id=42"))