152-ФЗ и AI: персональные данные в эпоху нейросетей

// Схема хранения согласий
interface ConsentRecord {
  id: string
  userId: string
  purpose: ConsentPurpose
  version: string           // версия документа согласия
  grantedAt: string         // ISO 8601
  revokedAt: string | null
  method: 'checkbox' | 'signature' | 'api'
  ipAddress: string         // для подтверждения
  userAgent: string
}

type ConsentPurpose =
  | 'chat_history'          // хранение истории чата
  | 'model_training'        // обучение модели
  | 'personalization'       // персонализация ответов
  | 'analytics'             // аналитика использования
  | 'document_processing'   // обработка загруженных документов

// API: получение согласия
app.post('/api/consent', async (req, res) => {
  const { userId, purpose, version } = req.body

  // Проверяем, что пользователь ещё не дал согласие на эту цель
  const existing = await db.consent.findFirst({
    where: { userId, purpose, revokedAt: null },
  })
  if (existing) return res.json({ already: true })

  const record = await db.consent.create({
    data: {
      userId,
      purpose,
      version,
      grantedAt: new Date().toISOString(),
      method: 'checkbox',
      ipAddress: req.ip,
      userAgent: req.headers['user-agent'],
    },
  })

  return res.json({ consent: record })
})

// API: отзыв согласия
app.post('/api/consent/revoke', async (req, res) => {
  const { userId, purpose } = req.body

  await db.consent.updateMany({
    where: { userId, purpose, revokedAt: null },
    data: { revokedAt: new Date().toISOString() },
  })

  // Запускаем удаление данных, связанных с этой целью
  await scheduleDataDeletion(userId, purpose)

  return res.json({ revoked: true })
})

// Middleware: проверка наличия согласия
async function requireConsent(purpose: ConsentPurpose) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const userId = req.user?.id
    if (!userId) return res.status(401).json({ error: 'Unauthorized' })

    const consent = await db.consent.findFirst({
      where: { userId, purpose, revokedAt: null },
    })

    if (!consent) {
      return res.status(403).json({
        error: 'consent_required',
        purpose,
        consentUrl: `/consent?purpose=${purpose}`,
      })
    }

    next()
  }
}

// Использование
app.post('/api/chat',
  requireConsent('chat_history'),
  async (req, res) => {
    // Обработка запроса к чат-боту
  },
)

app.post('/api/documents/upload',
  requireConsent('document_processing'),
  async (req, res) => {
    // Загрузка документа в RAG
  },
)

// Анонимизация ПД в тексте перед отправкой в внешний LLM API
interface AnonymizationMap {
  original: string
  replacement: string
  type: 'name' | 'phone' | 'email' | 'inn' | 'snils' | 'passport' | 'address'
}

function anonymizeText(text: string): {
  anonymized: string
  map: AnonymizationMap[]
} {
  const map: AnonymizationMap[] = []
  let result = text

  // ФИО (упрощённый паттерн)
  const namePattern = /[А-ЯЁ][а-яё]+\s+[А-ЯЁ][а-яё]+\s+[А-ЯЁ][а-яё]+/g
  result = result.replace(namePattern, (match) => {
    const id = `[PERSON_${map.length + 1}]`
    map.push({ original: match, replacement: id, type: 'name' })
    return id
  })

  // Телефоны
  const phonePattern = /(\+7|8)[\s-]?\(?\d{3}\)?[\s-]?\d{3}[\s-]?\d{2}[\s-]?\d{2}/g
  result = result.replace(phonePattern, (match) => {
    const id = `[PHONE_${map.length + 1}]`
    map.push({ original: match, replacement: id, type: 'phone' })
    return id
  })

  // Email
  const emailPattern = /[\w.-]+@[\w.-]+\.\w{2,}/g
  result = result.replace(emailPattern, (match) => {
    const id = `[EMAIL_${map.length + 1}]`
    map.push({ original: match, replacement: id, type: 'email' })
    return id
  })

  // ИНН (10 или 12 цифр)
  // NB: упрощённый паттерн — будет давать false positives на любых 10-12-значных числах.
  // В продакшене следует валидировать контрольную сумму ИНН.
  const innPattern = /\b\d{10}(\d{2})?\b/g
  result = result.replace(innPattern, (match) => {
    const id = `[INN_${map.length + 1}]`
    map.push({ original: match, replacement: id, type: 'inn' })
    return id
  })

  return { anonymized: result, map }
}

// Деанонимизация ответа
function deanonymize(text: string, map: AnonymizationMap[]): string {
  let result = text
  for (const entry of map) {
    result = result.replaceAll(entry.replacement, entry.original)
  }
  return result
}

// Использование с внешним LLM API
async function safeLLMCall(userPrompt: string): Promise<string> {
  const { anonymized, map } = anonymizeText(userPrompt)

  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: anonymized }],
  })

  const rawAnswer = response.choices[0].message.content ?? ''

  // Карту анонимизации храним только в памяти, не логируем
  return deanonymize(rawAnswer, map)
}

# Все ПД остаются на российском сервере
# Анонимизированные запросы к LLM — через прокси

upstream russian_backend {
    server 10.0.0.1:3000;  # Сервер приложения в РФ
}

server {
    listen 443 ssl;
    server_name api.myaiproduct.ru;

    # Все API-запросы с ПД — на российский сервер
    location /api/ {
        proxy_pass http://russian_backend;
    }

    # Статика, публичный контент — можно CDN
    location /static/ {
        proxy_pass http://cdn.myaiproduct.ru;
    }
}

// Аудит-лог операций с персональными данными
interface PDAuditLog {
  id: string
  timestamp: string         // ISO 8601
  action: PDAuditAction
  userId: string            // субъект ПД
  operatorId: string        // кто выполнил действие
  purpose: ConsentPurpose
  details: string           // описание операции
  dataCategories: string[]  // ['name', 'email', 'phone']
  legalBasis: 'consent' | 'contract' | 'legal_obligation' | 'legitimate_interest'
}

type PDAuditAction =
  | 'collect'       // сбор ПД
  | 'store'         // сохранение
  | 'process'       // обработка (включая отправку в LLM)
  | 'transfer'      // передача третьим лицам
  | 'anonymize'     // обезличивание
  | 'delete'        // удаление
  | 'access'        // доступ к ПД (запрос субъекта)
  | 'consent_grant' // получение согласия
  | 'consent_revoke'// отзыв согласия

async function logPDAction(entry: Omit<PDAuditLog, 'id' | 'timestamp'>) {
  await db.pdAuditLog.create({
    data: {
      ...entry,
      timestamp: new Date().toISOString(),
    },
  })
}

// Пример: логирование при отправке в LLM API
async function processWithLLM(userId: string, prompt: string) {
  const { anonymized, map } = anonymizeText(prompt)

  await logPDAction({
    action: 'anonymize',
    userId,
    operatorId: 'system',
    purpose: 'chat_history',
    details: `Anonymized ${map.length} PD entities before LLM call`,
    dataCategories: map.map(m => m.type),
    legalBasis: 'consent',
  })

  const response = await callLLM(anonymized)

  await logPDAction({
    action: 'process',
    userId,
    operatorId: 'system',
    purpose: 'chat_history',
    details: 'LLM API call with anonymized data',
    dataCategories: [],
    legalBasis: 'consent',
  })

  return deanonymize(response, map)
}

// Полное удаление данных пользователя
async function deleteUserData(userId: string, reason: 'revoke' | 'request' | 'expiry') {
  const deletionId = crypto.randomUUID()

  await logPDAction({
    action: 'delete',
    userId,
    operatorId: 'system',
    purpose: 'chat_history',
    details: `Data deletion initiated, reason: ${reason}, deletionId: ${deletionId}`,
    dataCategories: ['all'],
    legalBasis: reason === 'revoke' ? 'consent' : 'legal_obligation',
  })

  // 1. Удаляем историю чата
  await db.chatMessage.deleteMany({ where: { userId } })

  // 2. Удаляем загруженные документы и их чанки из векторной БД
  const documents = await db.document.findMany({ where: { userId } })
  for (const doc of documents) {
    await vectorDb.deleteByDocumentId(doc.id)
    await storage.delete(doc.storagePath)
  }
  await db.document.deleteMany({ where: { userId } })

  // 3. Удаляем профиль пользователя
  await db.userProfile.delete({ where: { id: userId } })

  // 4. Помечаем согласия как отозванные
  await db.consent.updateMany({
    where: { userId, revokedAt: null },
    data: { revokedAt: new Date().toISOString() },
  })

  // 5. Аудит-запись о завершении удаления
  // Используем deletionId вместо userId, т.к. данные удалены
  await db.pdAuditLog.create({
    data: {
      action: 'delete',
      userId: `deleted:${deletionId}`,
      operatorId: 'system',
      purpose: 'chat_history',
      details: `All PD deleted for deletion ${deletionId}`,
      dataCategories: ['all'],
      legalBasis: 'legal_obligation',
      timestamp: new Date().toISOString(),
    },
  })

  return { deletionId, completedAt: new Date().toISOString() }
}