Secret Scanning - Deteksi Hardcoded Secrets

Pendahuluan

Secret scanning adalah praktik keamanan yang bertujuan mendeteksi dan mencegah hardcoded secrets masuk ke dalam repository kode. Secrets meliputi API keys, authentication tokens, password, private keys, certificates, database connection strings, dan kredensial cloud (AWS Access Keys, Azure Service Principal, Google Service Account).

Menurut laporan GitGuardian 2023, lebih dari 10 juta hardcoded secrets bocor ke GitHub setiap tahunnya. Dampaknya bisa sangat serius:

Financial loss: Akun cloud dengan kredensial bocor bisa disalahgunakan untuk cryptomining, mengakibatkan tagihan hingga ratusan juta rupiah.
Data breach: Kredensial database yang bocor bisa memberikan akses ke data pelanggan.
Reputasi: Publikasi secret di repository publik adalah aib yang sulit dipulihkan.
Compliance violation: Kehilangan kredensial bisa melanggar PCI DSS, HIPAA, atau GDPR.

Mekanisme secret scanning melibatkan dua pendekatan utama:

Entropy-based detection: Mengukur entropy (tingkat keacakan) string - string dengan entropi tinggi lebih mungkin merupakan token atau kunci.
Pattern-based detection: Mencocokkan string dengan pola yang dikenal - misalnya AKIA[0-9A-Z]{16} untuk AWS Access Key, atau sk-[a-zA-Z0-9]{32,} untuk OpenAI API Key.

Tools Secret Scanning

GitLeaks

GitLeaks adalah tool open-source untuk mendeteksi hardcoded secrets di repository Git. GitLeaks bekerja dengan memindai commit history - termasuk komit yang sudah di-amend, squash, atau bahkan referensi di reflog.

Instalasi GitLeaks:

# Linux (binary)
wget https://github.com/gitleaks/gitleaks/releases/download/v8.18.2/gitleaks_8.18.2_linux_x64.tar.gz
tar -xzf gitleaks_8.18.2_linux_x64.tar.gz
sudo mv gitleaks /usr/local/bin/

# Atau via Homebrew (Linux)
brew install gitleaks

Menjalankan GitLeaks:

# Scan entire repository (termasuk history)
gitleaks detect --source . --verbose

# Scan staging area sebelum commit
gitleaks protect --staged

# Scan range komit tertentu
gitleaks detect --source . --log-opts="--since=2024-01-01"

# Output JSON
gitleaks detect --source . --report-path gitleaks-report.json --report-format json

Contoh konfigurasi GitLeaks (.gitleaks.toml):

title = "GitLeaks Configuration"

[allowlist]
description = "Allowlisted files and commits"
paths = [
  "test/**",
  "vendor/**",
  "*.test.*"
]
commits = [
  "0000000000000000000000000000000000000000"  # placeholder
]

[[rules]]
id = "aws-access-key"
description = "AWS Access Key"
regex = '''(?:A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}'''
tags = ["aws", "credentials", "cloud"]

[[rules]]
id = "github-pat"
description = "GitHub Personal Access Token"
regex = '''ghp_[a-zA-Z0-9]{36}|gho_[a-zA-Z0-9]{36}|ghu_[a-zA-Z0-9]{36}|ghs_[a-zA-Z0-9]{36}|ghr_[a-zA-Z0-9]{36}'''
tags = ["github", "token", "git"]

[[rules]]
id = "slack-token"
description = "Slack Bot Token"
regex = '''xox[baprs]-[0-9]{12}-[0-9]{12}-[a-zA-Z0-9]{24}'''
tags = ["slack", "token", "messaging"]

[[rules]]
id = "private-key"
description = "Private Key (RSA/EC/Ed25519)"
regex = '''-----BEGIN (RSA |EC |)PRIVATE KEY-----'''
tags = ["crypto", "ssh", "key"]

[[rules]]
id = "jwt-token"
description = "JWT Token (unsafe detection)"
regex = '''eyJ[a-zA-Z0-9]{10,}\.[a-zA-Z0-9]{10,}\.[a-zA-Z0-9_-]{10,}'''
tags = ["jwt", "token", "auth"]

[[rules]]
id = "openai-api-key"
description = "OpenAI API Key"
regex = '''sk-[a-zA-Z0-9]{32,48}'''
tags = ["openai", "api", "ai", "llm"]

[[rules]]
id = "google-service-account"
description = "Google Service Account Key"
regex = '''"type": "service_account"'''
files = ["*.json"]
tags = ["gcp", "google", "cloud", "service-account"]

TruffleHog

TruffleHog adalah tool secret scanning yang menggunakan teknik entropy analysis selain regex pattern matching. Ini memungkinkan TruffleHog mendeteksi secrets yang tidak memiliki pola yang dikenal.

Instalasi TruffleHog:

# Instalasi via pip
pip install truffleHog

# Atau via Docker
docker pull trufflesecurity/trufflehog

Menjalankan TruffleHog:

# Scan repository Git (seluruh history)
trufflehog git https://github.com/organisasi/repository.git --json

# Scan direktori lokal
trufflehog filesystem . --json

# Scan dengan deteksi hanya high entropy
trufflehog git https://github.com/org/repo.git \
  --only-verified \
  --fail

# Scan dengan output ke file
trufflehog git file:///home/user/project --json > trufflehog-report.json

Contoh output TruffleHog:

{
  "SourceMetadata": {
    "Data": {
      "Git": {
        "commit": "a1b2c3d4e5f6g7h8i9j0",
        "file": "src/config/credentials.py",
        "email": "[email protected]",
        "repository": "myapp",
        "timestamp": "2024-07-22 10:30:00",
        "line": 15
      }
    }
  },
  "SourceType": "GIT",
  "SourceID": 1,
  "DetectorType": 12,
  "DetectorName": "AWS",
  "DecoderType": "PlainText",
  "Verified": true,
  "Raw": "AKIAIOSFODNN7EXAMPLE",
  "Redacted": "AKIAIOSFODNN7EXAMPLE"
}

GitHub Secret Scanning

GitHub menyediakan secret scanning built-in untuk repository publik (gratis) dan private (dengan GitHub Advanced Security). GitHub secara otomatis memindai push dan mendeteksi pola dari lebih dari 200 service providers termasuk AWS, Azure, GCP, GitHub, Slack, dan OpenAI.

Saat secret terdeteksi:

GitHub mengirimkan notifikasi ke security manager dan kontributor.
Untuk known partners, GitHub otomatis memberi tahu provider tersebut - misalnya jika AWS Key bocor, GitHub langsung memberi tahu AWS.
Secret yang terdeteksi diblokir agar tidak bisa di-clone oleh pihak yang tidak berwenang.

GitLab Secret Detection

GitLab Secret Detection tersedia di GitLab Ultimate dan bekerja dengan menganalisis repository menggunakan ruleset yang mirip dengan Gitleaks. GitLab menyediakan CI/CD template siap pakai:

include:
  - template: Jobs/Secret-Detection.gitlab-ci.yml

secret_detection:
  variables:
    SECRET_DETECTION_HISTORIC_SCAN: "true"
    SECRET_DETECTION_EXCLUDED_PATHS: "vendor, node_modules, .git"

Pre-commit Hooks untuk Secret Scanning

Cara paling efektif untuk mencegah secrets masuk ke repository adalah dengan memblokirnya sebelum komit dibuat. Ini dicapai melalui pre-commit hooks.

Menggunakan pre-commit Framework

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/gitleaks/gitleaks
    rev: v8.18.2
    hooks:
      - id: gitleaks-docker
        args:
          - --verbose
          - --redact

  - repo: https://github.com/aws/git-secrets
    rev: master
    hooks:
      - id: git-secrets

Memasang hook:

pip install pre-commit
pre-commit install
pre-commit run --all-files

Menggunakan Lefthook

Lefthook adalah alternatif yang lebih cepat untuk pre-commit:

# lefthook.yml
pre-commit:
  commands:
    secret-scan:
      run: gitleaks protect --staged --verbose
      skip:
        - merge
        - rebase

pre-push:
  commands:
    secret-scan:
      run: gitleaks detect --source . --verbose

Instalasi Lefthook:

npm install -g @arkweid/lefthook
lefthook install

Custom Pre-commit Hook (Bash)

Jika tidak ingin menggunakan framework, buat file .git/hooks/pre-commit secara manual:

#!/bin/bash
# Pre-commit hook untuk secret scanning

echo "Menjalankan secret scanning..."

# Jalankan gitleaks
gitleaks protect --staged --verbose
if [ $? -ne 0 ]; then
  echo "ERROR: Secret scanning mendeteksi potensi hardcoded secret!"
  echo "Perbaiki sebelum commit. Gunakan 'git add -p' untuk staged file tertentu."
  exit 1
fi

echo "Secret scanning selesai - aman."
exit 0

Remediasi Secrets yang Sudah Bocor

Jika secret sudah terlanjur masuk ke repository - terutama repository publik - tindakan harus segera diambil.

Langkah Darurat

Revoke the secret: Segera cabut (revoke) kredensial yang bocor dari provider - buat key baru di AWS/GitHub/Google Cloud.
Rotate immediately: Ganti dengan kredensial baru di semua sistem yang menggunakannya.
Investigate log: Periksa akses log untuk melihat apakah kredensial sudah disalahgunakan.
Notify stakeholders: Beri tahu tim keamanan dan manajemen.

Menghapus Secret dari Riwayat Git

Menggunakan git filter-repo (direkomendasikan):

# Instalasi
pip install git-filter-repo

# Hapus file tertentu dari seluruh history
git filter-repo --path config/credentials.json --invert-paths

# Hapus berdasarkan pattern konten
git filter-repo --force \
  --replace-text <(echo "AKIAIOSFODNN7EXAMPLE")

# Hapus secret dari semua komit
git filter-repo --force \
  --path-glob '*.env' \
  --path-glob '*secret*' \
  --invert-paths

Menggunakan BFG Repo-Cleaner:

# Download BFG (jar)
wget https://repo1.maven.org/maven2/com/madgag/bfg/1.14.0/bfg-1.14.0.jar

# Hapus file dari history
java -jar bfg-1.14.0.jar --delete-files credentials.json repo.git

# Hapus folder
java -jar bfg-1.14.0.jar --delete-folders secrets repo.git

# Hapus text tertentu dari semua file
java -jar bfg-1.14.0.jar --replace-text passwords.txt repo.git

Peringatan Penting:

Git filter-repo dan BFG menulis ulang history - semua kolaborator harus force push ulang dan rebase.
Force push ke branch yang sudah dilindungi mungkin diblokir oleh GitHub/GitLab.
Setelah history dibersihkan, GitHub/GitLab mungkin masih menyimpan cache - hubungi support untuk pembersihan menyeluruh.
Jika repository adalah fork, fork juga harus dibersihkan.

Integrasi Secret Scanning di CI/CD Pipeline

Selain pre-commit hook, secret scanning harus dijalankan di CI/CD sebagai layer pertahanan kedua.

Contoh: GitLeaks di GitHub Actions

name: Secret Scanning
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]

jobs:
  gitleaks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Gitleaks Scan
        uses: gitleaks/gitleaks-action@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          GITLEAKS_LICENSE: ${{ secrets.GITLEAKS_LICENSE }}

      - name: Check Gitleaks Result
        if: failure()
        run: |
          echo "::error::Secret terdeteksi! Cek detail di atas."
          exit 1

Contoh: TruffleHog di GitLab CI

stages:
  - security

secret-scanning:
  stage: security
  image: trufflesecurity/trufflehog:latest
  script:
    - trufflehog git file://$CI_PROJECT_DIR
      --only-verified
      --fail
      --json > trufflehog-report.json
  artifacts:
    paths:
      - trufflehog-report.json
    when: always
  only:
    - merge_requests
    - main

Contoh: Custom Script untuk Monitoring Repository

#!/bin/bash
# monitor-secrets.sh - dijalankan periodik oleh cron

REPO_DIR="/path/to/repos"
ALERT_EMAIL="[email protected]"

for repo in $(ls $REPO_DIR); do
  cd "$REPO_DIR/$repo"
  git fetch origin

  # Bandingkan dengan HEAD sebelumnya
  PREV_HEAD=$(git rev-parse HEAD)
  git checkout origin/main

  gitleaks detect --source . --report-path /tmp/gitleaks-$repo.json
  if [ $? -ne 0 ]; then
    echo "Alert: Secret ditemukan di $repo" | \
      mail -s "[SECURITY] Secret ditemukan di $repo" $ALERT_EMAIL
  fi
done

Praktik Terbaik Secret Management

Gunakan .gitignore untuk file secrets: Tambahkan pola file seperti .env, *.key, credentials.*, secrets.*, *.pem, service-account.json ke .gitignore global.
Environment variables: Jangan pernah menyimpan secrets di kode. Gunakan environment variable yang dibaca saat runtime.
Vault/secrets manager: Gunakan tool seperti HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, atau Google Secret Manager untuk penyimpanan secrets terpusat.
.env.example: Simpan file .env.example di repository yang berisi placeholder tanpa nilai nyata - developer tinggal mengisi nilainya secara lokal.
Scanning berlapis: Terapkan secret scanning di tiga lapis: IDE (plugin), pre-commit hook, dan CI/CD pipeline.
Revocation automation: Miliki proses otomatis untuk revoke dan rotate kredensial yang bocor. Semakin cepat tindakan, semakin kecil dampaknya.
Training developer: Edukasi developer tentang bahaya hardcoded secrets dan praktik aman menyimpan kredensial.
Audit berkala: Lakukan full history scan secara periodik dengan GitLeaks atau TruffleHog untuk repository yang sudah berjalan lama.

Kesimpulan

Secret scanning adalah garis pertahanan pertama melawan salah satu ancaman keamanan paling umum dan paling berbahaya di era DevOps: hardcoded secrets di repository. Dengan satu komit yang ceroboh, seluruh infrastruktur cloud bisa jatuh ke tangan yang salah.

Kunci keberhasilan adalah shift-left dan layered defense. Mulailah dengan pre-commit hook menggunakan GitLeaks, perkuat dengan scanning di CI/CD, dan siapkan prosedur remediasi jika terjadi kebocoran. Jangan lupa untuk menginvestasikan waktu pada secrets management yang benar - vault, environment variable, dan rotation automation - karena mencegah selalu lebih baik daripada membersihkan.