Модуль корпоративной безопасности

graph TD
    A[Запрос пользователя] --> B[SecureLLMProvider]
    B --> C[Сканер DLP<br/>до/после]
    B --> D[Фильтр содержимого]
    B --> E[Журнал аудита LLM<br/>БД + SIEM]
    C --> F{Действие DLP}
    F -->|BLOCK| G[Запрос отклонён]
    F -->|MASK| H[Маскировка данных]
    F -->|WARN| I[Предупреждение в лог]
    F -->|LOG_ONLY| J[Запись в лог]
    D --> K[Поставщик LLM<br/>GigaChat / Yandex AI]
    E --> L[Диспетчер SIEM]
    L --> M[SysLog]
    L --> N[CEF]
    L --> O[LEEF]
    C --> P[Вебхук DLP]
    Q[HashiCorp Vault] -.->|Ротация секретов| B

┌─────────────────────────────────────────────────────────────────┐
│                     Запрос пользователя                          │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                     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:
    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"]

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

from src.security.llm.secure_provider import SecureLLMProvider

secure_provider = SecureLLMProvider(
    wrapped_provider=base_provider,
    config=get_security_config()
)

from src.llm import create_llm_provider

# Поставщик автоматически оборачивается в защитный слой
provider = create_llm_provider()

# Все запросы фильтруются и записываются в журнал
response = provider.generate(
    system_prompt="Вы — аналитик кода",
    user_prompt="Проанализируйте эту функцию",
)

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

# Создание базового поставщика
base_provider = GigaChatProvider(config)

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

# Использование защищённого поставщика
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)

# Сканирование содержимого
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

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

# Создание и отправка события
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)

from src.security.vault.client import VaultClient

client = VaultClient(config=vault_config)

from src.security.file_scanner import FileSecurityScanner

scanner = FileSecurityScanner()
result = scanner.scan_project("/path/to/project")

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}")

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

# Данные запроса Flask
request.args, request.form, request.json

# Стандартный ввод
input(), raw_input(), sys.stdin, os.getenv()

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

from src.security.taint_verified_scanner import TaintVerifiedScanner
from src.services.cpg import CPGQueryService

cpg_service = CPGQueryService(db_path)
scanner = TaintVerifiedScanner(cpg_service)

# Верификация результатов, связанных с SQL-инъекцией
verified = scanner.verify_sql_injection(raw_findings)

for finding in verified:
    print(f"Подтверждено: {finding.description}")
    print(f"Путь потока данных: {finding.taint_path}")

from src.security.hardening.hardening_scanner import HardeningScanner
from src.services.cpg import CPGQueryService

cpg_service = CPGQueryService(db_path)
scanner = HardeningScanner(cpg_service, language="c")
findings = scanner.scan_all(limit_per_check=50)

for finding in findings:
    print(f"[{finding.d3fend_id}] {finding.check_id}")
    print(f"  Серьёзность: {finding.severity}")
    print(f"  Рекомендация: {finding.remediation}")

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

from src.security.report_generator import ReportGenerator

generator = ReportGenerator()

# Создание отчёта
generator.create_report(
    project_name="MyProject",
    project_path="./myproject",
)

# Добавление результатов из разных источников
generator.add_cpg_findings(cpg_findings)
generator.add_dlp_findings(dlp_findings)
generator.add_hardening_findings(hardening_findings)

# Сохранение в нескольких форматах
generator.save_report(
    output_dir="./security_reports",
    formats=["json", "markdown", "sarif"],
    language="ru",
)

from src.analysis.autofix.engine import AutofixEngine

engine = AutofixEngine(source_root="/path/to/project", dry_run=True)
results = engine.generate_fixes(taint_paths=paths)

for result in results:
    print(f"[{result.strategy}] {result.cwe_id}: {result.fix.file_path}:{result.fix.line_number}")
    print(f"  Валидировано: {result.validated}, Уверенность: {result.fix.confidence}")

# config.yaml -> workflows.handlers.autofix
autofix:
  enabled: true
  context_lines_before: 10
  context_lines_after: 10
  llm_max_confidence: 0.6
  llm_temperature: 0.1
  llm_max_tokens: 2048
  max_fixes_per_run: 20

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": {}
}

# Полное сканирование проекта
python -m src.cli.security_audit full --path ./myproject --format all --verbose

# Быстрое сканирование (только файловый анализ)
python -m src.cli.security_audit quick --path ./myproject

# Просмотр текущих настроек безопасности
python -m src.cli.security_audit settings

# Поиск секретов в коде
python -m src.cli.security_audit secrets --path ./myproject

# Аудит с автоматическим формированием исправлений
python -m src.cli audit --autofix

codegraph_autofix(
    method_name="process_query",  # Фокус на конкретном методе
    cwe="CWE-89",                 # Фильтр по идентификатору CWE
)

codegraph_taint_analysis(
    method_name="handle_request",
    source_category="user_input",
    sink_category="sql",
)

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

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

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

# Полный аудит с автоисправлением
python -m src.cli audit --autofix

# Отчёты сохраняются в ./security_reports/
ls security_reports/
# security_audit_20241209_103000.json
# security_audit_20241209_103000.md
# security_audit_20241209_103000.sarif

# .github/workflows/security.yml
- 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