## Лучшие практики безопасности

Claude Code — это мощный AI-ассистент для программирования, но «мощный» также означает, что ему требуются высокие системные права — чтение и запись файлов, выполнение команд, доступ к сети. Это похоже на выдачу стажёру учётной записи администратора: возможности большие, но необходимы соответствующие границы безопасности.

Этот документ поможет вам выстроить комплексную систему защиты — от личного использования до командной работы, от среды разработки до автоматизации CI/CD, чтобы, наслаждаясь эффективностью AI-программирования, вы не наступили на грабли безопасности.

## Понимание модели безопасности Claude Code

### Claude Code работает в вашем терминале

Это крайне важно и является основой для понимания всех мер безопасности: **Claude Code работает не в облачной песочнице, а непосредственно в вашем локальном терминале**.

Это означает:

- Он может читать любые файлы на вашей машине (если у вашего пользователя есть права доступа)
- Он может выполнять любые Shell-команды
- Он может получить доступ к вашим переменным окружения (включая возможные ключи)
- Он может отправлять и получать данные через сеть

Конечно, Claude Code имеет встроенные механизмы безопасности для ограничения этих возможностей. Но вы всегда должны помнить этот основной факт: его максимальные права ограничены правами вашего пользователя.

### Механизм подтверждения разрешений

Основная концепция безопасности Claude Code — это **человек в цикле** (Human in the Loop). По умолчанию он запрашивает ваше подтверждение при выполнении следующих действий:

- Первое использование определённого инструмента
- Выполнение Shell-команды (особенно если она не была предварительно одобрена)
- Запись нового файла или изменение существующего
- Доступ к сетевым ресурсам

Запрос разрешения выглядит примерно так:

```
Claude wants to run: rm -rf node_modules && npm install

Allow?
  (y) Yes, allow once
  (a) Always allow "npm install" commands
  (n) No, deny
```

**Ключевой принцип**: если вы не уверены, безопасно ли определённое действие, выберите «No». Вы всегда можете одобрить его позже, когда разберётесь.

### Три линии обороны

Система безопасности Claude Code состоит из трёх линий обороны:

```
Первая линия: режим разрешений (глобальная политика)
  ↓
Вторая линия: правила Allow/Deny (тонкая настройка)
  ↓
Третья линия: Hooks (пользовательская логика перехвата)
```

Ниже мы рассмотрим каждую из них.

## Настройка разрешений

### Сравнение четырёх режимов разрешений

Claude Code предлагает четыре режима разрешений, от самого безопасного к наименее безопасному:

| Режим | Редактирование файлов | Выполнение команд | Сценарий использования | Уровень безопасности |
|------|---------|---------|---------|---------|
| `plan` | Запрещено | Запрещено (только чтение) | Обзор кода, архитектурный анализ | Максимальный |
| `default` | Запрос при первом использовании | Запрос при каждом выполнении | Повседневная разработка | Высокий |
| `acceptEdits` | Автоодобрение | Запрос при каждом выполнении | Частые изменения файлов | Средний |
| `bypassPermissions` | Автоодобрение | Автоодобрение | CI/CD, доверенная среда | Низкий |

**Подробное описание режимов:**

**Режим plan**: Claude может только искать и читать код, не может вносить никаких изменений. Подходит для случаев, когда вы хотите, чтобы Claude проанализировал код, но не хотите, чтобы он что-либо трогал. Переключиться в этот режим можно через `Shift+Tab`.

**Режим default**: рекомендуемый повседневный режим. Claude запрашивает разрешение при первом использовании инструмента определённого типа; после вашего одобрения аналогичные операции больше не запрашиваются. Shell-команды запрашиваются при каждом выполнении.

**Режим acceptEdits**: доверяет способностям Claude в редактировании файлов, но сохраняет осторожность в отношении выполнения команд. Подходит для случаев, когда вам нужно, чтобы Claude массово изменял файлы кода, но вы не хотите, чтобы он произвольно выполнял команды.

**Режим bypassPermissions**: пропускает все проверки разрешений. Используйте его только тогда, когда вы полностью уверены в текущей задаче или работаете в изолированной среде CI/CD.

### Просмотр и изменение через /permissions

В Claude Code в любой момент можно ввести `/permissions` для просмотра текущего состояния разрешений:

```
/permissions
```

Вывод покажет текущий режим, одобренные инструменты, правила Allow/Deny и т.д.

### Настройка разрешений в settings.json

Конфигурация разрешений хранится в `settings.json` на двух уровнях:

**Пользовательский** (влияет на все проекты): `~/.claude/settings.json`
**Проектный** (влияет только на текущий проект): `.claude/settings.json`

```json
{
  "permissions": {
    "defaultMode": "default",
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test:*)",
      "Bash(git status)",
      "Bash(git add:*)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(node:*)",
      "Bash(python:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(git push --force:*)",
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Read(.env)",
      "Read(.env.*)",
      "Read(secrets/**)"
    ]
  }
}
```

**Описание синтаксиса правил:**

| Синтаксис | Значение | Пример |
|------|------|------|
| `Bash(cmd)` | Точное совпадение команды | `Bash(npm run lint)` |
| `Bash(cmd:*)` | Совпадение по префиксу команды | `Bash(git log:*)` соответствует всем командам, начинающимся с `git log` |
| `Read(path)` | Совпадение при чтении файла | `Read(.env)` |
| `Write(path)` | Совпадение при записи файла | `Write(src/**)` |
| `**` | Многоуровневый подстановочный символ | `Read(secrets/**)` соответствует всем файлам на всех уровнях в secrets |
| `*` | Одноуровневый подстановочный символ | `Read(.env.*)` соответствует .env.local, .env.production и т.д. |

**Важно**: правила Deny имеют приоритет над правилами Allow. Даже если вы одобрили какое-либо действие в Allow, если оно также соответствует правилу Deny, оно будет отклонено.

## Защита конфиденциальных файлов

### Использование .claudeignore для исключения конфиденциальных каталогов

Синтаксис файла `.claudeignore` аналогичен `.gitignore`, и перечисленные в нём файлы и каталоги полностью невидимы для Claude Code:

Создайте `.claudeignore` в корневом каталоге проекта:

```gitignore
# Переменные окружения и ключи
.env
.env.*
secrets/
*.pem
*.key
*credentials*

# Конфиденциальные конфигурации
config/production.yml
config/secrets.yml

# Персональные данные
data/users/
*.sqlite
*.db

# Другие конфиденциальные каталоги
.aws/
.ssh/
.gnupg/
```

**Примечание**: `.claudeignore` делает файлы полностью невидимыми для Claude — он даже не знает об их существовании. Это более радикальный подход, чем правила Deny.

### Использование Hooks для перехвата изменений конфиденциальных файлов

Если вы хотите, чтобы Claude мог читать определённые файлы, но не мог их изменять, можно использовать Hooks для тонкой настройки:

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"\nimport sys, json, os\ntool_input = json.loads(os.environ.get('TOOL_INPUT', '{}'))\npath = tool_input.get('file_path', '') or tool_input.get('path', '')\nprotected = ['.env', 'credentials', 'secret', '.pem', '.key']\nfor p in protected:\n    if p in path.lower():\n        print(f'BLOCKED: не допускается изменение файлов, содержащих {p}', file=sys.stderr)\n        sys.exit(2)\n\""
          }
        ]
      }
    ]
  }
}
```

Этот Hook проверяет путь к файлу перед тем, как Claude попытается записать или отредактировать его; если путь содержит конфиденциальные ключевые слова, операция блокируется (exit code 2 означает блокировку).

### Защищённый шаблон конфигурации

Для командных проектов рекомендуется создать стандартный файл безопасной конфигурации, который будет храниться в репозитории:

```json
// .claude/settings.json (коммитится в Git)
{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(secrets/**)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Write(.git/**)",
      "Bash(rm -rf:*)",
      "Bash(git push --force:*)",
      "Bash(git reset --hard:*)",
      "Bash(chmod 777:*)",
      "Bash(curl|wget:*)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"$TOOL_INPUT\" | python3 -c \"import sys,json; cmd=json.load(sys.stdin).get('command',''); blocked=['DROP TABLE','DELETE FROM','TRUNCATE','password','token','secret']; [sys.exit(2) for b in blocked if b.lower() in cmd.lower()]\""
          }
        ]
      }
    ]
  }
}
```

## Безопасность выполнения команд

### Понимание поведения инструмента Bash

Claude Code выполняет Shell-команды через инструмент Bash. По умолчанию, за исключением предварительно одобренных вами команд, каждое выполнение требует подтверждения.

Некоторые моменты, на которые стоит обратить внимание:

- Команды выполняются в вашей текущей Shell-среде
- Переменные окружения видны командам
- Команды могут изменять файловую систему
- Команды могут устанавливать программное обеспечение
- Команды могут получать доступ к сети

### Какие команды автоматически одобряются

Когда вы добавляете определённый шаблон команды в список `allow` в `settings.json`, соответствующие команды выполняются автоматически без запросов.

Рекомендуемые к предварительному одобрению безопасные команды:

```json
{
  "permissions": {
    "allow": [
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(git branch:*)",
      "Bash(ls:*)",
      "Bash(cat:*)",
      "Bash(head:*)",
      "Bash(tail:*)",
      "Bash(wc:*)",
      "Bash(find:*)",
      "Bash(grep:*)",
      "Bash(npm run lint:*)",
      "Bash(npm run test:*)",
      "Bash(python -m pytest:*)"
    ]
  }
}
```

### Перехват опасных команд

Следующие команды всегда должны быть в списке Deny и никогда не должны выполняться автоматически:

```json
{
  "permissions": {
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(rm -r /:*)",
      "Bash(git push --force:*)",
      "Bash(git push -f:*)",
      "Bash(git reset --hard:*)",
      "Bash(git checkout -- .:*)",
      "Bash(git clean -f:*)",
      "Bash(chmod 777:*)",
      "Bash(chown:*)",
      "Bash(dd:*)",
      "Bash(mkfs:*)",
      "Bash(shutdown:*)",
      "Bash(reboot:*)"
    ]
  }
}
```

### Настройка перехвата команд через Hooks

Для более сложной логики перехвата используйте Hooks:

**Пример 1: блокировка всех сетевых команд**

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"$TOOL_INPUT\" | python3 -c \"\nimport sys, json\ncmd = json.load(sys.stdin).get('command', '')\nnet_cmds = ['curl', 'wget', 'nc ', 'netcat', 'ssh ', 'scp ', 'rsync']\nfor nc in net_cmds:\n    if nc in cmd:\n        print(f'BLOCKED: выполнение сетевых команд ({nc}) не допускается', file=sys.stderr)\n        sys.exit(2)\n\""
          }
        ]
      }
    ]
  }
}
```

**Пример 2: запись всех команд в журнал аудита**

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"$(date '+%Y-%m-%d %H:%M:%S') [Bash] $TOOL_INPUT\" >> ~/.claude/audit.log"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"$(date '+%Y-%m-%d %H:%M:%S') [FileChange] $TOOL_INPUT\" >> ~/.claude/audit.log"
          }
        ]
      }
    ]
  }
}
```

Таким образом у вас будет полный журнал аудита операций, позволяющий отследить, что делал Claude Code.

## Безопасность API-ключей

### Не встраивайте API-ключи в CLAUDE.md

Это самая распространённая ошибка безопасности. Файл `CLAUDE.md` обычно коммитится в Git-репозиторий, и Claude Code читает его при каждом запуске. Если он содержит API-ключ, то:

1. Ключ попадает в историю Git (даже если его удалить позже)
2. Ключ виден Claude Code и может появиться в логах или результатах анализа
3. Другие члены команды смогут увидеть этот ключ

**Неправильный подход:**

```markdown
<!-- CLAUDE.md -->
## Конфигурация API
Подключение к БД: postgresql://admin:P@ssw0rd@localhost:5432/mydb
OpenAI Key: sk-xxxxxxxxxxxxxxxxxxxx
```

**Правильный подход:**

```markdown
<!-- CLAUDE.md -->
## Конфигурация API
- Подключение к БД и API-ключи управляются через файл .env
- Файл .env не коммитится в Git (добавлен в .gitignore)
- Новым разработчикам нужно скопировать .env.example и ввести свои учётные данные
```

### Использование переменных окружения для управления ключами

Рекомендуемый способ управления ключами:

```bash
# .env (не коммитится в Git)
DATABASE_URL=postgresql://admin:P@ssw0rd@localhost:5432/mydb
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxx
REDIS_URL=redis://localhost:6379

# .env.example (коммитится в Git, без реальных значений)
DATABASE_URL=postgresql://user:password@localhost:5432/dbname
OPENAI_API_KEY=sk-your-key-here
REDIS_URL=redis://localhost:6379
```

Убедитесь, что `.env` добавлен в `.gitignore` и `.claudeignore`:

```gitignore
# .gitignore
.env
.env.local
.env.production

# .claudeignore (если вы не хотите, чтобы Claude читал .env)
.env
.env.*
```

### Действия при утечке API-ключа

Если вы подозреваете, что API-ключ был скомпрометирован (например, случайно запушен в Git), немедленно выполните следующие шаги:

```
1. Незамедлительно смените ключ
   - В консоли управления соответствующего сервиса создайте новый API-ключ
   - Обновите все переменные окружения, использующие этот ключ

2. Удалите из истории Git
   git filter-branch --force --index-filter \
     "git rm --cached --ignore-unmatch .env" \
     --prune-empty --tag-name-filter cat -- --all

   Или используйте более безопасный BFG Repo-Cleaner:
   bfg --delete-files .env
   git reflog expire --expire=now --all
   git gc --prune=now --aggressive

3. Принудительно запушьте очищенную историю
   git push --force --all

4. Проверьте наличие подозрительной активности
   - Посмотрите логи использования API на наличие аномальных вызовов
   - Проверьте биллинговые записи на предмет необычных расходов

5. Уведомите команду
   - Сообщите всем разработчикам о необходимости переклонировать репозиторий
   - Обновите ключи во всех средах развёртывания
```

## Правила безопасности для команды

### Общий шаблон settings.json

Создайте унифицированную базовую конфигурацию безопасности для команды и поместите её в `.claude/settings.json` репозитория проекта:

```json
{
  "permissions": {
    "defaultMode": "default",
    "allow": [
      "Bash(npm run:*)",
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(python -m pytest:*)"
    ],
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(secrets/**)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(**/*credential*)",
      "Write(.git/**)",
      "Bash(rm -rf:*)",
      "Bash(git push --force:*)",
      "Bash(git reset --hard:*)",
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(ssh:*)",
      "Bash(scp:*)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo \"$(date -Iseconds) TOOL_USE: $TOOL_INPUT\" >> .claude/audit.log"
          }
        ]
      }
    ]
  }
}
```

Члены команды могут добавлять личные настройки в `~/.claude/settings.json` (пользовательский уровень), но проектные правила Deny не могут быть переопределены.

### Настройка безопасности в CI/CD

При использовании Claude Code в среде CI/CD (Headless-режим) настройка безопасности ещё более важна:

```yaml
# Пример GitHub Actions
name: AI Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Claude Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude --print --dangerously-skip-permissions \
            "Просмотрите изменения кода в этом PR и дайте оценку безопасности и качества" \
            < /dev/null
```

**Рекомендации по безопасности CI/CD:**

| Пункт | Описание |
|--------|------|
| Управление API-ключами | Используйте Secrets платформы CI/CD (например, GitHub Secrets), не встраивайте ключи в код |
| Минимальные права | Claude Code в среде CI должен иметь только права на чтение, не должен изменять код |
| Сетевая изоляция | Ограничьте исходящий сетевой доступ среды CI |
| Настройка таймаутов | Установите разумный верхний предел времени выполнения для предотвращения аномально долгой работы |
| Очистка логов | Убедитесь, что в логах CI нет конфиденциальной информации |

### Меры безопасности в Headless-режиме

Headless-режим (`--print` или `-p`) используется в неинтерактивных сценариях, где нет человека для подтверждения операций. При его использовании следует проявлять особую осторожность:

```bash
# Безопасное использование Headless — операции только для чтения
claude --print "Проанализируйте структуру кода в каталоге src/"

# При необходимости записи ограничьте конкретными файлами
claude --print "Исправьте ошибки типов в src/utils.py"

# При использовании --dangerously-skip-permissions чётко осознавайте риски
claude --print --dangerously-skip-permissions "Запустите npm test"
```

Параметр `--dangerously-skip-permissions` имеет такое длинное имя именно для того, чтобы напоминать вам: пропуск проверки разрешений опасен. Используйте его только тогда, когда вы полностью контролируете входной промпт и точно знаете, какие операции могут выполняться.

## Корпоративная безопасность

### Контроль сетевого доступа

Если в вашей компании действуют строгие сетевые политики безопасности, вы можете контролировать сетевой доступ Claude Code следующим образом:

**1. Настройка прокси**

Установите HTTP-прокси через переменные окружения, тогда все сетевые запросы будут проходить через прокси для удобства аудита и контроля:

```bash
# Добавьте в .bashrc или .zshrc
export HTTP_PROXY=http://proxy.company.com:8080
export HTTPS_PROXY=http://proxy.company.com:8080
export NO_PROXY=localhost,127.0.0.1,.company.com
```

**2. Правила файрвола**

На корпоративном файрволе можно разрешить Claude Code доступ только к необходимым доменам:

```
# Обязательно разрешённые домены
api.anthropic.com         # Anthropic API
*.claude.ai               # Сервисы Claude

# Опционально разрешённые (в зависимости от используемых функций)
registry.npmjs.org         # Установка npm-пакетов
pypi.org                   # Установка Python-пакетов
github.com                 # Git-операции
```

**3. Запрет сетевых команд в settings.json**

В качестве дополнительного уровня безопасности добавьте в правила Deny запрет на распространённые сетевые утилиты:

```json
{
  "permissions": {
    "deny": [
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(nc:*)",
      "Bash(ssh:*)",
      "Bash(scp:*)",
      "Bash(rsync:*)",
      "Bash(ftp:*)",
      "Bash(telnet:*)"
    ]
  }
}
```

### Аудит логов

Для компаний с высокими требованиями к соответствию нормативным требованиям рекомендуется выстроить полноценную систему журналирования аудита:

**1. Операционные логи**

Записывайте все вызовы инструментов через Hooks:

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"\nimport json, os, datetime\nlog_entry = {\n    'timestamp': datetime.datetime.now().isoformat(),\n    'user': os.environ.get('USER', 'unknown'),\n    'tool': os.environ.get('TOOL_NAME', 'unknown'),\n    'input': os.environ.get('TOOL_INPUT', '')[:500]\n}\nwith open(os.path.expanduser('~/.claude/audit.jsonl'), 'a') as f:\n    f.write(json.dumps(log_entry, ensure_ascii=False) + '\\n')\n\""
          }
        ]
      }
    ]
  }
}
```

**2. Логи сессий**

Claude Code сам сохраняет историю сессий, которая хранится в каталоге `~/.claude/`. Компании могут периодически делать резервные копии этих логов.

**3. Отслеживание изменений**

В сочетании с Git все изменения файлов имеют полную историю отслеживания. Рекомендуется, чтобы каждое изменение Claude Code выполнялось в отдельной ветке и Merge выполнялся через PR-процесс.

### Вопросы соответствия требованиям

Использование AI-инструментов для программирования может затрагивать следующие вопросы соответствия:

**Безопасность данных**

| Риск | Меры противодействия |
|------|---------|
| Загрузка кода в облако | Claude Code не загружает ваш код на серверы Anthropic (кроме контекста в API-запросах) |
| Утечка конфиденциальных данных | Используйте .claudeignore для исключения конфиденциальных файлов; блокируйте чтение .env и ключевых файлов в правилах Deny |
| Конфиденциальная информация в API-запросах | Избегайте вставки паролей, токенов и другой конфиденциальной информации в диалог |

**Интеллектуальная собственность**

- Результаты работы Claude Code (сгенерированный код) принадлежат пользователю
- Обращайте внимание на то, содержит ли сгенерированный Claude код объекты, защищённые авторским правом
- Для критически важного бизнес-кода рекомендуется ручная проверка перед использованием

**Отраслевое соответствие**

- В регулируемых отраслях, таких как финансы и здравоохранение, могут существовать дополнительные ограничения на использование AI
- Убедитесь, что в вашей организации есть политика использования AI-инструментов
- Ведите журналы аудита для удовлетворения требований проверки соответствия

## Краткая шпаргалка по настройке безопасности

В заключение, вот краткий справочник чек-листа настроек безопасности:

### Минимальная настройка безопасности для индивидуального разработчика

```json
{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Bash(rm -rf:*)",
      "Bash(git push --force:*)"
    ]
  }
}
```

### Рекомендуемая настройка для командных проектов

```json
{
  "permissions": {
    "defaultMode": "default",
    "allow": [
      "Bash(npm run:*)",
      "Bash(git status)",
      "Bash(git diff:*)",
      "Bash(git log:*)"
    ],
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(secrets/**)",
      "Read(**/*.pem)",
      "Write(.git/**)",
      "Bash(rm -rf:*)",
      "Bash(git push --force:*)",
      "Bash(git reset --hard:*)",
      "Bash(curl:*)",
      "Bash(wget:*)"
    ]
  }
}
```

### Высокобезопасная корпоративная настройка

```json
{
  "permissions": {
    "defaultMode": "default",
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test)",
      "Bash(git status)",
      "Bash(git diff)"
    ],
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(secrets/**)",
      "Read(**/*.pem)",
      "Read(**/*.key)",
      "Read(**/*credential*)",
      "Read(**/*password*)",
      "Write(.git/**)",
      "Write(.github/**)",
      "Bash(rm:*)",
      "Bash(git push:*)",
      "Bash(git reset:*)",
      "Bash(git checkout -- :*)",
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(ssh:*)",
      "Bash(scp:*)",
      "Bash(nc:*)",
      "Bash(python -c:*)",
      "Bash(node -e:*)",
      "Bash(eval:*)",
      "Bash(exec:*)",
      "Bash(sudo:*)",
      "Bash(chmod:*)",
      "Bash(chown:*)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import json,os,datetime; f=open(os.path.expanduser('~/.claude/audit.jsonl'),'a'); f.write(json.dumps({'ts':datetime.datetime.now().isoformat(),'user':os.environ.get('USER','?'),'tool':os.environ.get('TOOL_NAME','?'),'input':os.environ.get('TOOL_INPUT','')[:500]},ensure_ascii=False)+'\\n'); f.close()\""
          }
        ]
      }
    ]
  }
}
```

## Часто задаваемые вопросы

**В: Отправляет ли Claude Code мой код на серверы Anthropic?**

О: Claude Code взаимодействует с Anthropic через API, контекст диалога (включая фрагменты кода, которые вы цитируете) отправляется как часть API-запроса. Однако Anthropic не использует данные, отправленные через API, для обучения моделей (согласно условиям использования Anthropic). Если вы используете Claude Code через промежуточный сервис, такой как QCode, пожалуйста, ознакомьтесь с политикой конфиденциальности этого сервиса.

**В: Может ли Claude обойти правила Deny в settings.json?**

О: При нормальном использовании — нет. Правила Deny принудительно выполняются на системном уровне, и Claude не может обойти их через промпт-инжиниринг или другими способами. Однако если вы вручную выберете режим `bypassPermissions` или используете параметр `--dangerously-skip-permissions`, эти правила перестанут действовать.

**В: В чём разница между .claudeignore и правилами Deny?**

О: `.claudeignore` делает файлы полностью невидимыми для Claude (подобно тому, как `.gitignore` работает для Git), тогда как правила Deny отклоняют доступ только когда Claude пытается к ним обратиться. Если вы не хотите, чтобы Claude знал о существовании определённых файлов, используйте `.claudeignore`; если вы просто не хотите, чтобы он их изменял, используйте правила Deny.

**В: При командной работе у каждого settings.json разный — что делать?**

О: Проектный `.claude/settings.json` коммитится в Git, что обеспечивает общую базовую конфигурацию безопасности для команды. Личные настройки можно добавить в `~/.claude/settings.json`, но они не могут переопределить проектные правила Deny.

**В: Безопаснее ли использовать Claude Code в Docker-контейнере?**

О: Да. Docker обеспечивает дополнительный уровень изоляции, поэтому даже если Claude Code выполнит непредвиденные операции, их влияние будет ограничено контейнером. Рекомендуется в контейнере: использовать монтирование исходного кода в режиме только для чтения, ограничивать сетевой доступ, запускать от имени непривилегированного пользователя.
## Безопасность MCP и песочница

MCP (Model Context Protocol) позволяет Claude Code подключаться к внешним инструментам и источникам данных — базам данных, API, файловым системам, сторонним сервисам и т. д. Это значительно расширяет его возможности, но также вносит новый класс рисков безопасности: **каждый добавленный MCP-сервер вводит в вашу границу доверия фрагмент стороннего кода и объявленные им права на инструменты**. О настройке и использовании MCP см. [Настройка MCP-сервера](/docs/advanced/mcp); этот раздел посвящён безопасности.

### Основные риски, привносимые MCP

- **Утечка данных**: вредоносный или скомпрометированный MCP-сервер может прочитать то, что вы ему передаёте (код, файлы, контекст диалога), и незаметно отправить это во внешнее место.
- **Отравление инструментов (Tool Poisoning)**: сервер встраивает скрытые инструкции в описание/метаданные инструмента, чтобы подтолкнуть модель к непредусмотренным действиям — разновидность инъекции промпта, нацеленная на вызовы инструментов AI.
- **Утечка учётных данных**: если сервер имеет доступ к переменным окружения или файлам с секретами, он может украсть API-ключи, токены и другие конфиденциальные учётные данные.
- **Чрезмерно широкие полномочия**: сервер, объявивший деструктивные инструменты вроде «удалить», «записать» или «выполнить команду», в случае выхода из-под контроля может нанести необратимый ущерб.

### Меры по снижению рисков

- **Устанавливайте только из доверенных источников**: устанавливайте только MCP-серверы из официальных или проверенных источников и оценивайте их надёжность так же, как любую стороннюю зависимость.
- **Проверяйте область полномочий каждого сервера**: перед подключением изучите каждый инструмент, объявленный сервером, и что он может делать, относясь к «чтению», «записи» и «выполнению» с разной степенью осторожности.
- **Сохраняйте контрольные точки одобрения человеком**: Claude Code запрашивает подтверждение перед вызовом инструмента. Для деструктивных операций и инструментов, работающих с учётными данными, **не** разрешайте всё разом — сохраняйте подтверждение при каждом использовании.
- **Блокируйте доступ к секретам через песочницу**: используйте настройку `sandbox.credentials`, чтобы команды, выполняемые в песочнице, не могли читать переменные окружения и файлы с секретами — тогда даже отравленный инструмент не получит учётных данных.
- **Принцип наименьших привилегий**: предоставляйте каждому MCP-серверу только минимальный набор инструментов и область доступа, необходимые для его задачи, — не открывайте всё ради удобства.
- **Аудит и журналирование**: фиксируйте вызовы инструментов и периодически пересматривайте, какие серверы вызываются и что они делали, чтобы аномальное поведение выявлялось рано.

Относитесь к каждому MCP-серверу как к внешнему подрядчику, входящему со своим набором инструментов, — сначала проверьте его личность, затем ограничьте то, к чему он может прикоснуться, и сохраните право подтверждать каждое действие. Так вы сможете пользоваться расширенными возможностями MCP, удерживая границу безопасности.