┌─────────────────────────────────────────────────────────────────┐
│                        Пользовательский запрос                   │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                     SecureLLMProvider                            │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐  │
│  │  Сканер DLP  │  │ Фильтр      │  │  Журнал запросов к   │  │
│  │  (до/после)  │  │ контента     │  │  LLM (БД + SIEM)     │  │
│  └──────────────┘  └──────────────┘  └──────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
         │                    │                    │
         ▼                    ▼                    ▼
┌──────────────┐     ┌──────────────┐     ┌──────────────────────┐
│  Действия DLP│     │ BaseLLMProv. │     │   Отправка в SIEM    │
│  BLOCK/MASK  │     │ (GigaChat)   │     │  ┌────┐┌────┐┌────┐ │
│  /WARN/LOG   │     │              │     │  │Sys ││CEF ││LEEF│ │
└──────────────┘     └──────────────┘     │  │Log ││    ││    │ │
         │                                 │  └────┘└────┘└────┘ │
         ▼                                 └──────────────────────┘
┌──────────────┐                                    │
│ Вебхук DLP   │                                    ▼
│ (внешний)    │                           ┌──────────────┐
└──────────────┘                           │    SIEM      │
                                           │  (Splunk/    │
┌──────────────┐                           │   QRadar)    │
│ HashiCorp    │◄── Ротация секретов       └──────────────┘
│ Vault        │
└──────────────┘

export SECURITY_ENABLED=true
export SIEM_ENABLED=true
export DLP_ENABLED=true

security:
  # Главный переключатель
  enabled: true

  # Логирование LLM
  llm_logging:
    enabled: true
    log_prompts: true
    redact_prompts: true
    max_prompt_length: 2000
    log_responses: true
    log_token_usage: true
    log_latency: true
    log_to_database: true

  # SIEM
  siem:
    enabled: true
    syslog:
      enabled: true
      protocol: "tls"  # udp, tcp, tls
      host: "siem.company.com"
      port: 6514
      facility: 16  # local0
      app_name: "codegraph"
    cef:
      enabled: true
      host: "arcsight.company.com"
      port: 514
    leef:
      enabled: false

  # DLP
  dlp:
    enabled: true
    pre_request:
      enabled: true
      default_action: "WARN"
    post_response:
      enabled: true
      default_action: "MASK"
    categories:
      credentials:
        enabled: true
        action: "BLOCK"
        severity: "critical"
      pii:
        enabled: true
        action: "MASK"
        severity: "high"
    webhook:
      enabled: true
      endpoint: "https://dlp.company.com/api/alerts"
      notify_on: ["BLOCK", "WARN"]

  # Vault
  vault:
    enabled: true
    url: "https://vault.company.com:8200"
    auth_method: "approle"
    secrets_mount_point: "secret"
    llm_secrets_path: "codegraph/llm"

from src.llm import create_llm_provider

# Поставщик автоматически оборачивается в защитный слой {#provider-is-automatically-wrapped-with-security-layer}
provider = create_llm_provider()

# Теперь все запросы фильтруются и записываются в лог {#all-requests-are-now-filtered-and-logged}
response = provider.generate(
    system_prompt="Вы — аналитик кода",
    user_prompt="Проанализируйте эту функцию",
)

from src.llm import GigaChatProvider
from src.security import get_security_config, SecureLLMProvider

# Создание базового поставщика {#create-base-provider}
base_provider = GigaChatProvider(config)

# Оборачивание в защитный слой {#wrap-with-security}
secure_provider = SecureLLMProvider(
    wrapped_provider=base_provider,
    config=get_security_config()
)

# Использование защищённого поставщика {#use-secure-provider}
response = secure_provider.generate(
    system_prompt="Проанализируй код",
    user_prompt="def process_payment(card_number='4111111111111111')...",
    _user_id="user-123",  # Опционально: контекст пользователя
    _ip_address="192.168.1.100",  # Опционально: IP для аудита
)

from src.security.dlp import ContentScanner
from src.security.config import get_security_config

config = get_security_config()
scanner = ContentScanner(config.dlp)

# Сканирование содержимого {#scan-content}
result = scanner.scan_request("API_KEY=sk-1234567890abcdef")

if result.blocked:
    print(f"Контент заблокирован! Совпадения: {result.matches}")
elif result.has_matches:
    print(f"Обнаружены конфиденциальные данные: {result.matches}")
    # Использовать замаскированный контент
    safe_content = result.modified_content

from src.security.siem import (
    SecurityEvent, SecurityEventType,
    init_siem_dispatcher
)
from src.security.config import get_security_config

# Инициализация диспетчера {#initialize-dispatcher}
dispatcher = init_siem_dispatcher(get_security_config().siem)

# Создание и отправка события {#create-and-dispatch-event}
event = SecurityEvent.create(
    event_type=SecurityEventType.DLP_BLOCK,
    message="Учётные данные обнаружены в запросе LLM",
    severity=3,  # Ошибка
    user_id="user-123",
    request_id="req-456",
    details={"pattern": "aws_key", "category": "credentials"}
)

dispatcher.dispatch(event)

dlp:
  categories:
    custom:
      enabled: true
      action: "WARN"
      severity: "medium"
      patterns:
        - name: "project_code"
          regex: "PROJECT-[A-Z]{2,4}-\d{4,6}"
          mask_with: "[PROJECT-ID]"

<134>1 2024-12-09T10:30:00.000Z codegraph.company.com codegraph - llm.dlp.block [llm@12345 requestId="req-123" userId="user-456" provider="GigaChat" action="BLOCK" category="credentials"] DLP BLOCK: 2 patterns in request

CEF:0|CodeGraph|CodeAnalysis|1.0|llm.dlp.block|DLP Block|7|rt=Dec 09 2024 10:30:00 src=192.168.1.100 suser=user-456 cs1=req-123 cs1Label=RequestID cs2=GigaChat cs2Label=Provider act=BLOCK cat=credentials

LEEF:2.0|CodeGraph|CodeAnalysis|1.0|llm.dlp.block|  devTime=Dec 09 2024 10:30:00    src=192.168.1.100   usrName=user-456    requestId=req-123   provider=GigaChat   action=BLOCK    category=credentials

{
  "alert_id": "a1b2c3d4e5f6",
  "timestamp": "2024-12-09T10:30:00.000Z",
  "action": "BLOCK",
  "match_count": 2,
  "categories": ["credentials"],
  "patterns": ["api_key", "aws_key"],
  "request_id": "req-123",
  "user_id": "user-456",
  "ip_address": "192.168.1.100",
  "severity": "critical",
  "context": {}
}

from src.security.file_scanner import FileSecurityScanner

scanner = FileSecurityScanner()
result = scanner.scan("/путь/к/проекту")

print(f"Критические: {result.critical_count}")
print(f"Высокий уровень: {result.high_count}")

for finding in result.findings:
    print(f"{finding.severity}: {finding.description}")
    print(f"  Файл: {finding.file_path}:{finding.line_number}")

# Быстрое сканирование {#quick-scan}
python -m src.cli.security_audit quick --path ./myproject

# Полное сканирование с отчётом {#full-scan-with-report}
python -m src.cli.security_audit full --path ./myproject --format all

# Данные запроса Django {#django-request-data}
request.GET, request.POST, request.data
request.body, request.FILES, request.META

# Данные запроса Flask {#flask-request-data}
request.args, request.form, request.json

# Обычный ввод {#generic-input}
input(), raw_input(), sys.stdin, os.getenv()

# Ввод из файлов или сети {#filenetwork-input}
open(), read(), recv(), urlopen()

from src.security.taint_verified_scanner import TaintVerifiedScanner

scanner = TaintVerifiedScanner(duckdb_path="cpg.duckdb")

# Проверка результатов, связанных с SQL-инъекцией {#verify-sql-injection-findings}
verified = scanner.verify_sql_injection_findings(raw_findings)

for finding in verified:
    print(f"Подтверждено: {finding['description']}")
    print(f"Путь заражения: {finding['taint_path']}")

from src.security.hardening import HardeningScanner

scanner = HardeningScanner(duckdb_path="cpg.duckdb")
results = scanner.run_all_checks()

for result in results:
    print(f"[{result.check.d3fend_id}] {result.check.d3fend_name}")
    print(f"  Нарушения: {len(result.violations)}")
    print(f"  Рекомендации: {result.check.remediation}")

security:
  hardening:
    enabled: true
    checks:
      D3-VI: true    # Инициализация переменных
      D3-CS: true    # Очистка учётных данных
      D3-NPC: true   # Проверка на null-указатели
    severity_threshold: "medium"  # Пропускать низкий уровень угроз

from src.security.sast_comparison import SASTComparison

comparison = SASTComparison(project_path="./myproject")

# Сравнение с Bandit {#compare-with-bandit}
result = comparison.compare_with_bandit(our_findings)

print(f"Точность: {result.precision:.2%}")
print(f"Полнота: {result.recall:.2%}")
print(f"F1-мера: {result.f1_score:.2%}")
print(f"Уникальные для нас: {len(result.only_ours)}")
print(f"Пропущенные нами: {len(result.only_theirs)}")

# Сравнение с Bandit {#compare-with-bandit}
python -m src.cli.security_audit full --path ./myproject --compare bandit

# Сравнение с Semgrep {#compare-with-semgrep}
python -m src.cli.security_audit full --path ./myproject --compare semgrep

from src.security.report_generator import SecurityReportGenerator

generator = SecurityReportGenerator(language="en")

# Генерация отчёта на основе результатов сканирования {#generate-report-from-scan-results}
report = generator.generate(
    project_name="MyProject",
    project_path="./myproject",
    file_findings=file_scan.findings,
    cpg_findings=cpg_scan.findings,
    hardening_findings=hardening_results,
)

# Экспорт в разные форматы {#export-to-different-formats}
generator.export_json(report, "report.json")
generator.export_markdown(report, "report.md")
generator.export_sarif(report, "report.sarif")

from src.security.cpg_context_resolver import CPGContextResolver

resolver = CPGContextResolver(duckdb_path="cpg.duckdb")

# Обогащение результата контекстом {#enrich-finding-with-context}
enriched = resolver.enrich_finding(finding)

print(f"Вызывающие: {enriched['callers']}")
print(f"Поток данных: {enriched['data_flow_path']}")
print(f"Модуль: {enriched['module']}")

src/security/
├── __init__.py          # Экспорты модуля
├── _base.py             # Базовые классы (Severity, Category)
├── config.py            # Конфигурация безопасности
│
├── dlp/                 # Предотвращение утечки данных (DLP)
│   ├── patterns.py      # Шаблоны DLP (учетные данные, персональные данные)
│   ├── scanner.py       # Сканер содержимого
│   ├── actions.py       # Действия DLP (BLOCK, MASK, WARN)
│   └── webhook.py       # Вебхуки оповещений
│
├── siem/                # Интеграция с SIEM
│   ├── base_handler.py  # Базовый класс обработчика
│   ├── syslog_handler.py
│   ├── cef_handler.py
│   ├── leef_handler.py
│   ├── buffer.py        # Буферизация событий
│   └── dispatcher.py    # Диспетчеризация между несколькими обработчиками
│
├── vault/               # HashiCorp Vault
│   ├── client.py        # Клиент API Vault
│   └── secret_manager.py
│
├── llm/                 # Безопасность LLM
│   ├── secure_provider.py  # Обёртка SecureLLMProvider
│   └── request_logger.py   # Аудит и логирование запросов
│
├── hardening/           # Усиление безопасности (D3FEND)
│   ├── base.py          # Определения проверок
│   ├── d3fend_checks.py # Все проверки D3FEND
│   └── hardening_scanner.py
│
├── patterns/            # Шаблоны уязвимостей
│   ├── injection.py     # Инъекции SQL/команд
│   ├── memory.py        # Безопасность работы с памятью
│   ├── crypto.py        # Криптографические проблемы
│   ├── auth.py          # Ошибки аутентификации
│   ├── concurrency.py   # Гонки данных (race conditions)
│   └── python_django.py # Специфичные для Python/Django
│
├── file_scanner.py      # Сканирование на основе файлов
├── taint_verified_scanner.py  # Анализ загрязнения (taint analysis)
├── cpg_context_resolver.py    # Обогащение CPG
├── sast_comparison.py   # Сравнение инструментов SAST
├── report_generator.py  # Генерация отчётов
└── report_localizer.py  # Поддержка интернационализации (i18n)

# Переменные окружения {#environment-variables}
export SECURITY_ENABLED=true
export DLP_ENABLED=true
export SIEM_ENABLED=true

# Полный аудит со всеми проверками {#full-audit-with-all-checks}
python -m src.cli.security_audit full \
    --path ./myproject \
    --format all \
    --verbose

# Отчёты сохраняются в ./security_reports/ {#reports-are-saved-to-security-reports}
ls security_reports/
# security_audit_20241209_103000.json {#security-audit-20241209-103000json}
# security_audit_20241209_103000.md {#security-audit-20241209-103000md}
# security_audit_20241209_103000.sarif {#security-audit-20241209-103000sarif}

# .github/workflows/security.yml {#githubworkflowssecurityyml}
- name: Security Audit
  run: |
    python -m src.cli.security_audit full \
      --path . \
      --format sarif \
      --output security.sarif

- name: Upload SARIF
  uses: github/codeql-action/upload-sarif@v2
  with:
    sarif_file: security.sarif