Security
Overview
The Security validator scans merge requests for potential security issues, including hardcoded secrets in code, commit messages, and changes to sensitive files.
Configuration
Optional Properties
scanForSecrets: Enable secret scanning (boolean, default:true)secretPatterns: Regex patterns for secret detection (list of strings, default: built-in patterns)sensitiveFiles: Glob patterns for sensitive files (list of strings, default: built-in patterns)scan: Controls diff scanning behaviour (SecurityScanConfig, default: see sub-properties below)maxDiffSize: Maximum diff size to scan for secrets, measured in UTF-8 bytes (not characters). Diffs exceeding this threshold are skipped with a finding (seeseverities.largeDiffSkipped). Must be between 64KB and 50MB, otherwise the config is rejected (size, default:1MB)severities: Controls the severity of specific security findings (SecuritySeverityConfig, default: see sub-properties below).secretFound: Severity when a secret is detected:"error","warning"or"info"(string, default:"error")largeDiffSkipped: Severity when a diff is too large to scan:"error","warning"or"info"(string, default:"warning")- Any other value is rejected when the config loads (
severities.secretFound must be one of [error, warning, info]) instead of silently becomingerror.
Examples
Basic Usage - Default Patterns
karandash {
rules {
security {
scanForSecrets = true
}
}
}
Custom Secret Patterns
karandash {
rules {
security {
scanForSecrets = true
secretPatterns = listOf(
"(?i)(api[_-]?key|apikey)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-]{20,}['\"]?",
"(?i)(password|passwd)\\s*[:=]\\s*['\"]?[^\\s'\"]{8,}['\"]?",
"my-company-secret-pattern"
)
}
}
}
Custom Sensitive Files
karandash {
rules {
security {
sensitiveFiles = listOf(
"**/.env*",
"**/config/secrets.yml",
"**/credentials/**",
"**/*.pem",
"**/*.key"
)
}
}
}
Strict Security Policy
karandash {
rules {
security {
scanForSecrets = true
secretPatterns = listOf(
// API Keys
"(?i)(api[_-]?key|apikey)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-]{20,}['\"]?",
// Passwords
"(?i)(password|passwd|pwd)\\s*[:=]\\s*['\"]?[^\\s'\"]{8,}['\"]?",
// AWS Keys
"(?i)(aws[_-]?access[_-]?key[_-]?id)\\s*[:=]\\s*['\"]?[A-Z0-9]{20}['\"]?",
// Private Keys
"(?i)(private[_-]?key)\\s*[:=]\\s*['\"]?-----BEGIN",
// Tokens
"(?i)(token|bearer)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-\\.]{20,}['\"]?"
)
sensitiveFiles = listOf(
"**/.env*",
"**/secrets/**",
"**/*.pem",
"**/*.key",
"**/*.p12",
"**/id_rsa"
)
}
}
}
Default Secret Patterns
Karandash includes built-in patterns for common secrets:
// API Keys
"(?i)(api[_-]?key|apikey)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-]{20,}['\"]?"
// Secret Keys
"(?i)(secret[_-]?key|secretkey)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-]{20,}['\"]?"
// Passwords
"(?i)(password|passwd|pwd)\\s*[:=]\\s*['\"]?[^\\s'\"]{8,}['\"]?"
// Access Tokens
"(?i)(access[_-]?token|accesstoken)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-]{20,}['\"]?"
// Bearer Tokens
"(?i)(bearer\\s+[a-zA-Z0-9_\\-\\.]{20,})"
// AWS Access Keys
"(?i)(aws[_-]?access[_-]?key[_-]?id)\\s*[:=]\\s*['\"]?[A-Z0-9]{20}['\"]?"
// AWS Secret Keys
"(?i)(aws[_-]?secret[_-]?access[_-]?key)\\s*[:=]\\s*['\"]?[a-zA-Z0-9/+=]{40}['\"]?"
// Private Keys
"(?i)(private[_-]?key)\\s*[:=]\\s*['\"]?-----BEGIN"
// GitHub Tokens
"(?i)(github[_-]?token|gh[_-]?token)\\s*[:=]\\s*['\"]?ghp_[a-zA-Z0-9]{36}['\"]?"
// GitLab Tokens
"(?i)(gitlab[_-]?token|gl[_-]?token)\\s*[:=]\\s*['\"]?glpat-[a-zA-Z0-9_\\-]{20}['\"]?"
Default Sensitive Files
**/.env
**/.env.*
**/config/secrets.yml
**/config/credentials.yml
**/*secret*
**/*credential*
**/*.pem
**/*.key
**/*.p12
**/*.pfx
**/id_rsa
**/id_dsa
Error Messages
- Secret in commit:
Potential secret detected in commit message: {sha} - Secret in a diff:
Potential secret in an added line(on the file and line; the path is the finding's location, not part of the message) - Secret in title:
Potential secret detected in MR title - Secret in description:
Potential secret detected in MR description - Sensitive file:
Sensitive file change detected: {path}(WARNING severity) - Invalid pattern:
Invalid regex pattern in secret patterns configuration: '{pattern}' - {error}
Best Practices
When to Use This Rule
- Prevent accidental secret commits
- Detect credential leaks before merge
- Flag sensitive file changes for extra review
- Implement security compliance requirements
- Protect production credentials
Secret Detection Strategy
Multi-Layer Approach:
- Pre-commit: Git hooks scan locally
- MR Validation: Karandash scans during review
- CI/CD: Additional scanning in pipeline
- Repository Scanning: Regular historical scans
Where Secrets Are Scanned
rules {
security {
scanForSecrets = true
}
}
Scans commit messages, the MR title and the MR description. It does not scan file contents (use CI/CD tools for that).
Recommendation: Combine with dedicated secret scanning tools: - GitGuardian - TruffleHog - git-secrets - detect-secrets
Sensitive Files Strategy
rules {
security {
sensitiveFiles = listOf(
"**/.env*", // Environment configs
"**/config/secrets.yml", // Secret configs
"**/*.pem", // Certificates
"**/*.key", // Private keys
"**/credentials/**" // Credential directories
)
}
}
This generates WARNING findings to alert reviewers.
Tips
- Customize patterns for your organization's secret formats
- Use environment variables for secrets, never hardcode
- Document secret management practices
- Use secret management tools (Vault, AWS Secrets Manager)
- Combine with pre-commit hooks for early detection
- Regular security audits of repository history
Common Secret Patterns
API Keys
// Generic API key
"(?i)(api[_-]?key|apikey)\\s*[:=]\\s*['\"]?[a-zA-Z0-9_\\-]{20,}['\"]?"
// Service-specific
"(?i)stripe[_-]key\\s*[:=]\\s*['\"]?sk_(test|live)_[a-zA-Z0-9]{24}['\"]?"
"(?i)slack[_-]token\\s*[:=]\\s*['\"]?xox[abp]-[a-zA-Z0-9\\-]{10,}['\"]?"
Cloud Provider Credentials
// AWS
"(?i)aws[_-]?access[_-]?key[_-]?id\\s*[:=]\\s*['\"]?[A-Z0-9]{20}['\"]?"
"(?i)aws[_-]?secret[_-]?access[_-]?key\\s*[:=]\\s*['\"]?[a-zA-Z0-9/+=]{40}['\"]?"
// GCP
"(?i)gcp[_-]?key\\s*[:=]\\s*['\"]?.*['\"]?"
// Azure
"(?i)azure[_-]?key\\s*[:=]\\s*['\"]?[a-zA-Z0-9/+=]{40,}['\"]?"
Database Credentials
// Connection strings
"(?i)(mongodb|mysql|postgres)://[^\\s]+:[^\\s]+@"
// Database passwords
"(?i)db[_-]?(password|passwd)\\s*[:=]\\s*['\"]?[^\\s'\"]{8,}['\"]?"
Private Keys
// SSH/TLS Keys
"(?i)-----BEGIN (RSA |DSA |EC |OPENSSH )?PRIVATE KEY-----"
// PGP Keys
"(?i)-----BEGIN PGP PRIVATE KEY BLOCK-----"
False Positive Management
Common False Positives
Example values in documentation:
# This will trigger false positive:
api_key = "YOUR_API_KEY_HERE"
# Better approach (in docs):
api_key = "<your-api-key>"
api_key = "${API_KEY}" # Reference to env var
Test fixtures:
// Use obviously fake values:
const val TEST_API_KEY = "test-key-not-real-12345"
const val MOCK_PASSWORD = "mock-password-for-testing"
Excluding False Positives
Option 1: Use placeholder patterns
const apiKey = process.env.API_KEY; // Won't trigger
const apiKey = "sk_test_abc123"; // Will trigger
Option 2: Customize patterns to be more specific
// Too broad (many false positives)
"(?i)password\\s*[:=]"
// More specific (fewer false positives)
"(?i)password\\s*[:=]\\s*['\"](?!test|mock|example)[^\\s'\"]{8,}['\"]"
Sensitive File Warnings
When sensitive files are changed:
⚠️ WARNING: Sensitive file change detected: config/secrets.yml
Actions to take: 1. Extra reviewer scrutiny 2. Verify no secrets in diff 3. Make sure proper secret management 4. Check file is in .gitignore if needed 5. Verify deployment process handles secrets correctly
Combining with Other Rules
With File Changes
rules {
security {
scanForSecrets = true
sensitiveFiles = listOf("**/.env*", "**/*.key")
}
fileChanges {
patterns = listOf(
FilePatternRule(
pattern = "**/*.key",
requireApproval = listOf("security-team")
)
)
}
}
With Approvals
rules {
security {
scanForSecrets = true
}
approval {
requiredApprovers = listOf("security-team")
}
}
With Labels
rules {
security {
sensitiveFiles = listOf("**/secrets/**")
}
labels {
conditionalLabels = listOf(
ConditionalLabel(
condition = LabelCondition(hasLabel = "security"),
requiredLabels = listOf("security-review", "pen-test")
)
)
}
}
Secret Management Best Practices
Do
- Use environment variables
- Use secret management services (Vault, AWS Secrets Manager)
- Use
.envfiles (add to .gitignore) - Rotate secrets regularly
- Use different secrets for dev/staging/prod
- Encrypt secrets at rest
Don't
- Commit secrets to version control
- Share secrets via chat/email
- Reuse secrets across environments
- Use default/example secrets in production
- Log secrets in application logs
- Include secrets in error messages
Integration with Secret Scanning Tools
Pre-commit Hooks
# .git/hooks/pre-commit
#!/bin/sh
karandash validate-local --rules security
CI/CD Pipeline
# .gitlab-ci.yml
security-scan:
stage: security
script:
- karandash validate --rules security
- trufflehog filesystem .
- gitleaks detect
Compliance Requirements
For regulated industries (HIPAA, PCI-DSS, SOC2):
rules {
security {
scanForSecrets = true
secretPatterns = listOf(
// Add industry-specific patterns
"(?i)(ssn|social.security)\\s*[:=]\\s*\\d{3}-\\d{2}-\\d{4}",
"(?i)(credit.card|ccn)\\s*[:=]\\s*\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}"
)
}
}
Related Rules
- File Changes - Monitor sensitive file patterns
- Approvals - Require security team approval
- Labels - Tag security-related changes
- Codeowners - Security team as code owners