20 - Security and Privacy with Claude Code

// ~/.claude/settings.json - Global user settings
{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "LS"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(sudo *)",
      "Bash(chmod 777 *)",
      "Bash(curl * | bash)",
      "Bash(wget * | sh)"
    ],
    "auto_approve": [
      "Write(src/**/*.ts)",
      "Write(src/**/*.html)",
      "Write(src/**/*.css)",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(npm run build)"
    ]
  },
  "mcp": {
    "trusted_servers": [
      "filesystem",
      "github"
    ],
    "untrusted_behavior": "ask"
  }
}

// Recommended deny list
{
  "permissions": {
    "deny": [
      // Destructive commands
      "Bash(rm -rf /)",
      "Bash(rm -rf ~)",
      "Bash(rm -rf .)",
      "Bash(:(){ :|:& };:)",

      // Privilege escalation
      "Bash(sudo *)",
      "Bash(su *)",
      "Bash(chmod 777 *)",
      "Bash(chown *)",

      // Unverified remote execution
      "Bash(curl * | bash)",
      "Bash(curl * | sh)",
      "Bash(wget * -O - | bash)",
      "Bash(eval $(curl *))",

      // Dangerous network operations
      "Bash(nc -l *)",
      "Bash(ncat *)",
      "Bash(socat *)",

      // System file modification
      "Write(/etc/**)",
      "Write(/usr/**)",
      "Write(/var/**)",
      "Write(~/.ssh/**)",
      "Write(~/.aws/**)",
      "Write(~/.config/gcloud/**)",

      // Access to secrets
      "Read(~/.ssh/id_rsa)",
      "Read(~/.ssh/id_ed25519)",
      "Read(~/.aws/credentials)",
      "Read(**/.env.production)",
      "Read(**/secrets.*)",

      // Git force push
      "Bash(git push --force *)",
      "Bash(git push -f *)",
      "Bash(git reset --hard *)"
    ]
  }
}

# In Anthropic account settings:
# 1. Go to Settings > Privacy
# 2. Disable "Help improve Claude"
# 3. This disables the use of your data for training

# Verify from the CLI:
claude settings --show privacy
# Output:
# {
#   "data_sharing": {
#     "help_improve_claude": false,
#     "usage_analytics": true,
#     "crash_reports": true
#   }
# }

# To disable everything:
claude settings --set privacy.help_improve_claude false
claude settings --set privacy.usage_analytics false

# WRONG: secrets exposed in the prompt
claude "Configure the database with host: db.example.com,
user: admin, password: S3cr3tP@ss!, database: production"

# CORRECT: reference to environment variables
claude "Configure the database using the environment variables
DB_HOST, DB_USER, DB_PASSWORD, DB_NAME that are already set
in the .env file (do not read the .env file, just use the variable names)"

# WRONG: API key in the code
claude "Add the API call with the key sk-1234567890abcdef"

# CORRECT: use placeholders and external configuration
claude "Add the API call reading the key from the
environment variable API_KEY. Never hardcode the key in the source."

# AI-generated code verification pipeline

# 1. Automated static analysis
npm run lint                          # ESLint for JavaScript/TypeScript
./mvnw checkstyle:check             # Checkstyle for Java
pylint src/                          # Pylint for Python

# 2. Security scanning
npm audit                            # npm dependency vulnerabilities
./mvnw dependency-check:check       # OWASP Dependency Check
snyk test                            # Snyk vulnerability scan
semgrep --config=auto src/           # Security patterns

# 3. Secrets detection
gitleaks detect                      # Search for secrets in code
trufflehog filesystem --directory=.  # Search for hardcoded credentials

# 4. Automated tests
npm test -- --coverage               # Unit tests with coverage
npm run test:integration             # Integration tests
npm run test:e2e                     # End-to-end tests

# 5. Human code review
# Manual review focusing on:
# - Input validation
# - SQL injection
# - XSS (Cross-Site Scripting)
# - CSRF (Cross-Site Request Forgery)
# - Authentication/Authorization
# - Error handling (no sensitive info in errors)
# - Logging (no secrets in logs)

# Prompt requesting secure defaults
claude "Implement the POST /api/users endpoint with the following
MANDATORY security requirements:

1. Input Validation:
   - Validate all fields with Bean Validation annotations
   - Sanitize input to prevent XSS
   - Limit field lengths (name max 100, email max 254)

2. SQL Injection Prevention:
   - Use ONLY parameterized queries (JPA/Hibernate)
   - NEVER concatenate strings for SQL queries

3. Authentication:
   - Endpoint protected by JWT
   - Verify ADMIN role for user creation

4. Password Security:
   - Hash with bcrypt (min 12 rounds)
   - NEVER log or return the password
   - Complexity validation (min 8 chars, upper, lower, digit, special)

5. Error Handling:
   - Return generic error messages to the user
   - Log technical details only in server logs
   - NEVER expose stack traces or internal details

6. Rate Limiting:
   - Max 10 requests per minute per IP
   - Max 3 creation attempts per account

7. Logging:
   - Log user creation (audit trail)
   - NEVER log sensitive data (passwords, tokens)"

# .claudeignore - Files excluded from Claude Code context

# Secrets and credentials
.env
.env.*
*.pem
*.key
*.p12
*.pfx
secrets/
credentials/
**/secrets.*
**/credentials.*

# SSH keys and sensitive configurations
.ssh/
.aws/
.gcloud/
.azure/

# Configuration files with passwords
**/application-prod.yml
**/application-prod.properties
**/database.yml
docker-compose.prod.yml

# Personal data and GDPR
data/users/
data/personal/
exports/pii/
backups/

# Large files (not useful for context)
*.zip
*.tar.gz
*.sql.gz
node_modules/
dist/
build/
target/
.gradle/

# Vendor and dependencies
vendor/
bower_components/

# Logs that might contain sensitive data
logs/
*.log

# Temporary files
tmp/
temp/
.cache/

// /etc/claude-code/managed-settings.json
// Enterprise configuration (requires admin privileges)
{
  "content_exclusion": {
    "global_patterns": [
      "**/.env*",
      "**/secrets/**",
      "**/credentials/**",
      "**/*.pem",
      "**/*.key",
      "**/application-prod.*"
    ],
    "enforce": true,
    "override_allowed": false
  },
  "permissions": {
    "deny": [
      "Bash(rm -rf *)",
      "Bash(sudo *)",
      "Bash(git push --force *)",
      "Write(/etc/**)",
      "Write(~/.ssh/**)"
    ],
    "max_auto_approve_scope": "project_only"
  },
  "data_handling": {
    "help_improve_claude": false,
    "log_retention_days": 30,
    "audit_all_operations": true
  }
}

// .claude/settings.json - Committed to the repository
// Shared among all team developers
{
  "project": {
    "name": "MyApp",
    "description": "Enterprise web application"
  },
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Grep",
      "Write(src/**)",
      "Write(tests/**)",
      "Write(docs/**)",
      "Bash(npm *)",
      "Bash(npx *)",
      "Bash(git *)"
    ],
    "deny": [
      "Write(.env*)",
      "Write(**/secrets/**)",
      "Read(.env.production)",
      "Bash(rm -rf *)",
      "Bash(sudo *)",
      "Bash(git push --force *)",
      "Bash(docker run --privileged *)",
      "Bash(npm publish)"
    ],
    "auto_approve": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(npm run build)"
    ]
  },
  "content_exclusion": [
    ".env*",
    "secrets/",
    "*.key",
    "*.pem",
    "docker-compose.prod.yml"
  ]
}

// Audit logging configuration
// ~/.claude/settings.json
{
  "audit": {
    "enabled": true,
    "log_directory": "~/.claude/audit-logs/",
    "log_level": "detailed",
    "events": [
      "file_read",
      "file_write",
      "file_delete",
      "command_execute",
      "mcp_tool_invoke",
      "permission_request",
      "permission_granted",
      "permission_denied",
      "session_start",
      "session_end"
    ],
    "retention_days": 365,
    "format": "json"
  }
}

# Example audit log entry:
# {
#   "timestamp": "2026-02-14T10:23:45.123Z",
#   "session_id": "sess_abc123",
#   "user": "developer@company.com",
#   "event": "file_write",
#   "details": {
#     "file": "src/app/services/user.service.ts",
#     "operation": "modify",
#     "lines_changed": 15,
#     "permission": "auto_approved"
#   }
# }

# Setup script for a new developer on the team
#!/bin/bash
# setup-claude-security.sh

echo "Configuring Claude Code security for the team..."

# 1. Create configuration directory
mkdir -p ~/.claude

# 2. Copy the team's base configuration
cp /shared/team-config/claude-settings.json ~/.claude/settings.json

# 3. Verify that the deny list is active
echo "Verifying deny list..."
claude settings --show permissions.deny
echo ""

# 4. Verify sensitive content exclusion
echo "Verifying content exclusion..."
claude settings --show content_exclusion
echo ""

# 5. Disable data sharing for training
claude settings --set privacy.help_improve_claude false
echo "Data sharing for training: DISABLED"

# 6. Enable audit logging
claude settings --set audit.enabled true
claude settings --set audit.log_level detailed
echo "Audit logging: ENABLED"

# 7. Configure team-approved MCP servers
echo "Configuring approved MCP servers..."
claude mcp trust github
claude mcp trust filesystem
echo "Only team-approved MCP servers are enabled"

# 8. Verify final configuration
echo ""
echo "=== Configuration Complete ==="
claude settings --show | head -30
echo ""
echo "Remember:"
echo "- NEVER include secrets in prompts"
echo "- Code review ALL generated code"
echo "- Report any anomalous behavior to the security team"