- docs.qcode.cc

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

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

{
  "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 в корневом каталоге проекта:

# Переменные окружения и ключи
.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 для тонкой настройки:

{
  "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 означает блокировку).

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

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

// .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, соответствующие команды выполняются автоматически без запросов.

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

{
  "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 и никогда не должны выполняться автоматически:

{
  "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: блокировка всех сетевых команд

{
  "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: запись всех команд в журнал аудита

{
  "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-ключ, то:

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

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

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

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

<!-- CLAUDE.md -->
## Конфигурация API

- Подключение к БД и API-ключи управляются через файл .env
- Файл .env не коммитится в Git (добавлен в .gitignore)
- Новым разработчикам нужно скопировать .env.example и ввести свои учётные данные

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

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

# .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
.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 репозитория проекта:

{
  "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-режим) настройка безопасности ещё более важна:

# Пример 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) используется в неинтерактивных сценариях, где нет человека для подтверждения операций. При его использовании следует проявлять особую осторожность:

# Безопасное использование 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-прокси через переменные окружения, тогда все сетевые запросы будут проходить через прокси для удобства аудита и контроля:

# Добавьте в .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 запрет на распространённые сетевые утилиты:

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

Аудит логов ¶

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

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

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

{
  "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-инструментов
Ведите журналы аудита для удовлетворения требований проверки соответствия

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

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

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

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

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

{
  "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 выполнит непредвиденные операции, их влияние будет ограничено контейнером. Рекомендуется в контейнере: использовать монтирование исходного кода в режиме только для чтения, ограничивать сетевой доступ, запускать от имени непривилегированного пользователя.

← Предыдущая

Модель сотрудничества суб-агентов

Интеграция с VS Code

🚀

Начните с QCode — ИИ-ассистент для программистов

Официальный ретранслятор Claude Code, быстро и надёжно

Посмотреть тарифы → Создать аккаунт