Skip to main content
skill CX Codex

secret-scanner — Claude Code skill: what it does, how to install

secret-scanner catches exposed API keys, database credentials, and tokens in code before they leak into git commits.

MIT ★ 788 updated 2026-07-03

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add alirezarezvani/claude-code-tresor --skill secret-scanner -a claude-code
Open on GitHub

What secret-scanner does

The skill intercepts file modifications, changes in .env files, and pre-commit actions to inspect code for exposed sensitive data. It relies solely on Read and Grep tools to match patterns for AWS access keys, Stripe tokens, GitHub credentials, JWT strings, and private SSH keys.

It also verifies whether sensitive configuration paths exist inside .gitignore. While real keys trigger hard commit blocks, mock credentials inside test fixtures or documentation examples get marked with lower priority to prevent noise.

Network access is completely unnecessary because all checks run against the local filesystem with read-only permissions.

What it helps with

  • prevent committing raw API keys and database tokens to git
  • verify sensitive config files against .gitignore rules
  • refactor hardcoded credentials into environment variables
  • scan source trees for misplaced SSH and SSL private keys

Example prompts for the agent

  • Scan modified files for exposed API keys before I commit
  • Check docker-compose.yml for plaintext passwords and move them to .env
  • Inspect the repository for leaking credentials and verify .gitignore

How to install secret-scanner

1Skills CLI (Vercel)

npx skills add alirezarezvani/claude-code-tresor --skill secret-scanner -a claude-code

2Manually: put the files in place

~/.claude/skills/secret-scanner/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/secret-scanner/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about secret-scanner

How to install secret-scanner in Claude Code?

Run npx skills add alirezarezvani/claude-code-tresor --skill secret-scanner -a claude-code in your terminal.

What does secret-scanner do?

It spots exposed credentials, tokens, and private keys during editing and stops git commits until sensitive values are moved to environment variables.

Does this skill require network access?

No, it functions purely offline using read-only filesystem operations with Read and Grep.

Source text

SKILL.md · MIT
---
name: secret-scanner
description: Detect exposed secrets, API keys, credentials, and tokens in code. Use before commits, on file saves, or when security is mentioned. Prevents accidental secret exposure. Triggers on file changes, git commits, security checks, .env file modifications.
allowed-tools: Read, Grep
---

# Secret Scanner Skill

Prevent accidental secret exposure in your codebase.

## When I Activate

- ✅ Before git commits
- ✅ Files modified/saved
- ✅ User mentions secrets, keys, or credentials
- ✅ .env files changed
- ✅ Configuration files modified

## What I Detect

### API Keys & Tokens
- AWS access keys (AKIA...)
- Stripe API keys (sk_live_..., pk_live_...)
- GitHub tokens (ghp_...)
- Google API keys
- OAuth tokens
- JWT secrets

### Database Credentials
- Database connection strings
- MySQL/PostgreSQL passwords
- MongoDB connection URIs
- Redis passwords

### Private Keys
- SSH private keys
- RSA/DSA keys
- PGP/GPG keys
- SSL certificates

### Authentication Secrets
- Password variables
- Auth tokens
- Session secrets
- Encryption keys

## Alert Examples

### API Key Detection
```javascript
// You type:
const apiKey = 'sk_live_1234567890abcdef';

// I immediately alert:
🚨 CRITICAL: Exposed Stripe API key detected!
📍 File: config.js, Line 3
🔧 Fix: Use environment variables
  const apiKey = process.env.STRIPE_API_KEY;
📖 Add to .gitignore: .env
```

### AWS Credentials
```python
# You type:
aws_access_key = "AKIAIOSFODNN7EXAMPLE"

# I alert:
🚨 CRITICAL: AWS access key exposed!
📍 File: aws_config.py, Line 1
🔧 Fix: Use AWS credentials file or environment variables
  aws_access_key = os.getenv("AWS_ACCESS_KEY_ID")
📖 Never commit AWS credentials
```

### Database Password
```yaml
# You type in docker-compose.yml:
environment:
  DB_PASSWORD: "mySecretPassword123"

# I alert:
🚨 CRITICAL: Database password in configuration file!
📍 File: docker-compose.yml, Line 5
🔧 Fix: Use .env file
  DB_PASSWORD: ${DB_PASSWORD}
📖 Add .env to .gitignore
```

## Detection Patterns

### Pattern Types

**High Confidence:**
- Known API key formats (Stripe, AWS, etc.)
- Private key headers
- JWT tokens
- Connection strings with credentials

**Medium Confidence:**
- Variables named "password", "secret", "key"
- Base64 encoded strings in sensitive contexts
- Long random strings in assignments

**Low Confidence (Flagged for Review):**
- Generic secret patterns
- Potential credentials in comments

## Git Integration

### Pre-Commit Protection

```bash
# Before commit, I scan:
git add .
git commit

# I block if secrets found:
🚨 CRITICAL: Cannot commit - secrets detected!
📍 3 secrets found:
  - config.js:12 - API key
  - .env:5 - Database password (in gitignore - OK)
  - auth.js:45 - JWT secret

❌ Commit blocked - remove secrets first
```

### .gitignore Validation

I check if sensitive files are in .gitignore:

```
✅ .env - In .gitignore (good)
⚠️ config/secrets.json - NOT in .gitignore (add it!)
✅ .aws/credentials - In .gitignore (good)
```

## False Positive Handling

### Example Files
```javascript
// I understand these are examples:
// Example: const apiKey = 'your_api_key_here';
// TODO: Add your API key from environment
```

### Test Files
```javascript
// Test fixtures are OK (but flagged for review):
const mockApiKey = 'sk_test_1234567890abcdef';  // ✅ Test key
```

### Documentation
```markdown
<!-- Documentation examples are flagged but low priority -->
Set your API key: `export API_KEY=your_key_here`
```

## Relationship with security-auditor

**secret-scanner (me):** Exposed secrets and credentials
**security-auditor:** Code vulnerability patterns

### Together
```
secret-scanner: Finds hardcoded API key
security-auditor: Finds how the key is used insecurely
Combined: Complete security picture
```

## Quick Fixes

### Move to Environment Variables

```javascript
// Before:
const apiKey = 'sk_live_abc123';

// After:
const apiKey = process.env.API_KEY;

// .env file (add to .gitignore):
API_KEY=sk_live_abc123
```

### Use Secret Management

```javascript
// AWS Secrets Manager
const AWS = require('aws-sdk');
const secrets = new AWS.SecretsManager();
const secret = await secrets.getSecretValue({ SecretId: 'myApiKey' }).promise();
```

### Configuration Files

```yaml
# docker-compose.yml
services:
  app:
    environment:
      - API_KEY=${API_KEY}  # From .env file

# .env (gitignored)
API_KEY=sk_live_abc123
```

## Sandboxing Compatibility

**Works without sandboxing:** ✅ Yes (recommended)
**Works with sandboxing:** ✅ Yes

- **Filesystem**: Read-only access
- **Network**: None required
- **Configuration**: None required

## Customization

Add company-specific secret patterns:

```bash
cp -r ~/.claude/skills/security/secret-scanner \
      ~/.claude/skills/security/company-secret-scanner

# Edit SKILL.md to add:
# - Internal API key formats
# - Company-specific secret patterns
# - Custom detection rules
```

## Best Practices

1. **Never commit secrets** - Use environment variables
2. **Use .gitignore** - Add .env, secrets.json, etc.
3. **Rotate exposed secrets** - If committed, rotate immediately
4. **Use secret management** - AWS Secrets Manager, HashiCorp Vault
5. **Audit regularly** - Review code for exposed secrets

## Emergency Response

### If Secret Committed

1. **Rotate the secret immediately**
2. **Remove from git history**
   ```bash
   git filter-branch --force --index-filter \
     "git rm --cached --ignore-unmatch config/secrets.json" \
     --prune-empty --tag-name-filter cat -- --all
   ```
3. **Force push** (coordinate with team)
4. **Update all deployments** with new secret

## Related Tools

- **security-auditor skill**: Vulnerability detection
- **@code-reviewer sub-agent**: Security review
- **/review command**: Comprehensive security check

© alirezarezvani · MIT · alirezarezvani/claude-code-tresor

Similar skills

All skills for Security →

From the same set27

The whole set →
agent agent — a prompt for LLM engineers. Builds and refines prompts across Claude, GPT and open models — from system instructions to reasoning chains, with model-specific adaptation. GP ChatGPT ★ 788repo stars dependency-auditor dependency-auditor is a skill that checks dependencies for vulnerabilities and license issues, then suggests fixes. Run it after dependency file changes or before deployment. CX Codex +1 ★ 788repo stars test-gen test-gen writes test suites against existing code: unit tests for functions, component tests, integration and e2e suites, API tests. Framework and coverage come from flags. CX Codex +1 ★ 788repo stars api-documenter The api-documenter skill builds API specifications from routes and code comments. Use it when endpoints change or the project needs an OpenAPI document. CX Codex +1 ★ 788repo stars readme-updater readme-updater updates README automatically when project structure changes, dependencies are added, or new features land. CX Codex +1 ★ 788repo stars test-generator test-generator produces initial unit test scaffolding for new functions and UI components across popular testing libraries. CX Codex +1 ★ 788repo stars docs-gen The docs-gen command turns a codebase into API docs, guides, and reference material. Use it when you need a documentation site or automated deployment. CX Codex +1 ★ 788repo stars scaffold scaffold writes a project or component skeleton with source files, configs, tests and docs. Flags decide the framework and the extra pieces. CX Codex +1 ★ 788repo stars

Project sponsors

Companies that keep this analytics open