rxb06/credactorScannez. Expurgez. Committez proprement.
[](https://pypi.org/project/credactor/)
[](https://github.com/rxb06/credactor/actions/workflows/ci.yml)
[](https://github.com/rxb06/credactor/blob/main/LICENSE)
# Credactor
**Trouvez le secret. Corrigez-le. Committez proprement.**
Les scanners de secrets savent bien donner l'alerte, mais sont peu utiles pour l'éteindre. Ils vous remettent une liste d'identifiants compromis et vous laissent le nettoyage. Credactor boucle la boucle : il trouve un secret codé en dur et le réécrit sur place, de sorte qu'une fuite passe de la détection à la correction en une seule commande.
<img alt="Credactor: scan, redact, commit clean" src="https://assets.kitploit.com/production/public/readmes/9024/3abc948c69d942141474c93431f182cf98a738ebbd43f94eef8f92fda2498f18.png" width="1280" height="320" />
Garder les identifiants hors du code source est une pratique de sécurité de base, pas une option. Credactor rend cette base peu coûteuse à maintenir, sur votre machine avant un commit ou en CI avant une fusion. Lancez-le seul, ou aux côtés des scanners auxquels vous faites déjà confiance.
```python
# Credactor finds this:
db_password = "h8Tq2vKp9mRz4Wd"
# By default it rewrites the secret as a sentinel that fails loudly at runtime:
db_password = "REDACTED_BY_CREDACTOR"
# With --replace-with env, it writes a reference that reads from the environment:
db_password = os.environ["DB_PASSWORD"]
```
> La rédaction réécrit les fichiers dans votre **arbre de travail**. Si un secret a déjà été committé, faites tourner la clé et nettoyez aussi l'historique (par exemple, avec `git filter-repo`). Réécrire un fichier ne remplace pas la révocation d'un identifiant compromis.
---
## Pourquoi Credactor
- **Rédaction, pas seulement détection.** La plupart des scanners s'arrêtent à la détection. Credactor remplace le secret sur place : un sentinelle bruyante `REDACTED_BY_CREDACTOR` qui échoue à l'exécution par défaut, ou une référence à une variable d'environnement adaptée au langage (Python, JavaScript/TypeScript, Go, Java/Kotlin, Ruby, PHP et shell) telle que `os.environ["KEY"]`. Le remplacement est du code valide. Si le fichier n'inclut pas déjà l'import correspondant (par exemple `import os`), ajoutez-le.
- **Sûr par défaut.** Écritures atomiques, sauvegardes `.bak` automatiques, protections contre les limites de liens symboliques et les permissions de fichiers, et masquage complet des secrets dans toutes les sorties. Si une sauvegarde sûre ne peut pas être écrite, Credactor ignore le fichier plutôt que de le réécrire à l'aveugle, et un plantage en cours d'écriture laisse l'original intact.
- **Zéro dépendance à l'exécution.** Bibliothèque standard Python 3.11+ pure, plus un extra optionnel pour les encodages non-UTF-8.
- **Conçu pour le pipeline.** Sortie SARIF pour GitHub Code Scanning, une barrière `--ci` en lecture seule avec des codes de sortie précis, un hook pre-commit, et l'ingestion des rapports Gitleaks, TruffleHog ou Betterleaks. Détectez avec le scanner que vous exécutez déjà, remédiez avec Credactor.
## Installation
```bash
pip install credactor
```
Nécessite Python 3.11+. Aucune autre dépendance. Fonctionne sur Linux, macOS et
Windows (testé en CI sur Linux et Windows).
Sur macOS et Linux, vous pouvez l'installer avec Homebrew à la place :
```bash
brew install rxb06/tap/credactor
```
La formule s'installe dans son propre virtualenv et inclut l'extra optionnel
`[encoding]`, donc une installation Homebrew détecte aussi les secrets dans les
fichiers non-UTF-8. Un simple `pip install credactor` omet cet extra ; ajoutez-le avec
`pip install 'credactor[encoding]'` si vous voulez la même couverture.
Depuis les sources :
```bash
git clone https://github.com/rxb06/credactor.git
cd credactor
pip install -e .
```
`credactor` fonctionne alors depuis n'importe quel répertoire.
## Démarrage rapide
> Lancez d'abord `--dry-run` et examinez les résultats avant de rédiger. Les faux positifs sont possibles, et sous `--fix-all` un faux positif est réécrit. Supprimez les valeurs connues comme sûres avec `# credactor:ignore` ou une entrée `.credactorignore`.
```bash
credactor --dry-run . # scan, change nothing
credactor . # scan, then redact interactively (y/n per finding)
credactor --fix-all . # redact everything after one confirmation
credactor --fix-all --yes . # redact non-interactively (CI / scripts)
credactor --ci . # read-only gate: exit 1 on findings
credactor --replace-with env . # redact to env-var references instead of the sentinel
```
### Hook pre-commit
> Le hook ne filtre que le contenu indexé, donc un secret déjà committé n'est pas
> re-signalé. Utilisez `credactor --scan-history .` pour vérifier ce qui est déjà dans le dépôt.
```yaml
# .pre-commit-config.yaml
repos:
- repo: https://github.com/rxb06/credactor
rev: v2.7.4 # pin to the latest release tag
hooks:
- id: credactor
```
### GitHub Action
```yaml
- uses: rxb06/[email protected]
```
L'action passe toujours `--ci`, donc elle signale et bloque mais ne réécrit jamais le
checkout. Les résultats font échouer l'étape ; définissez `fail-on-findings: false` pour signaler
sans bloquer. Une erreur fait échouer l'étape dans tous les cas.
Téléversez vers Code Scanning au lieu d'échouer sur les résultats :
```yaml
- uses: rxb06/[email protected]
with:
format: sarif
upload-sarif: true
fail-on-findings: false
```
Le job a besoin de `permissions: security-events: write` pour le téléversement. Consultez le
[guide d'intégration CI](https://github.com/rxb06/credactor/blob/main/docs/ci_integration.md#github-action) pour chaque entrée,
y compris l'ingestion des rapports Gitleaks, TruffleHog et Betterleaks.
## Détection
Credactor détecte les types d'identifiants qui fuient le plus souvent, et attribue à chacun une sévérité pour que vous puissiez trier en un coup d'œil.
| Catégorie | Exemples | Sévérité |
|---|---|---|
| Clés de fournisseurs cloud | AWS (`AKIA…`), GCP (`AIza…`), Stripe (`sk_live_…`), Slack (`xoxb-…`) | Critique |
| Jetons de plateformes | GitHub (`ghp_`, `github_pat_`), GitLab (`glpat-`), npm (`npm_`), PyPI (`pypi-`) | Critique |
| Clés privées | Blocs PEM (`-----BEGIN … PRIVATE KEY-----`) | Critique |
| JWT | Jetons `eyJ…` à trois segments | Élevée |
| Chaînes de connexion | URL avec identifiants en ligne (`scheme://user:pass@host`) | Élevée |
| Variables d'identifiants | `password = "…"`, `api_key = "…"`, `secret_key = "…"` | Élevée/Moyenne/Faible |
| Attributs XML | `<add key="Password" value="…" />` | Élevée/Moyenne/Faible |
| Chaînes à haute entropie | hex entre guillemets (32–64 caractères) / Base64 (60+ caractères) | Moyenne/Faible |
Les jetons de fournisseurs déterministes (les préfixes ci-dessus) sont signalés indépendamment de l'entropie. Les détecteurs heuristiques (JWT, chaînes de connexion, hex, Base64) doivent franchir un seuil d'entropie. Un hex ou Base64 isolé n'est signalé que lorsqu'il est entre guillemets. Une valeur à haute entropie non entre guillemets n'est capturée que sur une variable nommée comme un identifiant, ce qui épargne les SHA de git et les sommes de contrôle. Pour les règles complètes de détection et de sévérité, consultez le [Manuel](https://github.com/rxb06/credactor/blob/main/docs/manual.md#detection--severity).
> L'ensemble de règles natif de Credactor est plus étroit que celui d'un scanner dédié, et certains formats de fournisseurs (par exemple SendGrid, Twilio et les webhooks Slack) ne sont pas détectés. Son atout est la remédiation : associez-le à Gitleaks, TruffleHog ou Betterleaks pour la détection la plus large, ou exécutez-le seul.
## Associez-le à un autre scanner, rédigez le tout
Credactor tient debout seul, et il se renforce en compagnie. Vous exécutez déjà Gitleaks, TruffleHog ou Betterleaks ? Passez leur rapport à Credactor et il rédige l'ensemble combiné, dédupliqué par rapport à ses propres résultats (en cas de chevauchement, la sévérité la plus élevée l'emporte). Une seule passe de remédiation couvre votre scan et le leur :
```bash
gitleaks dir . -f json -r gitleaks.json
credactor --from-gitleaks gitleaks.json --fix-all --yes .
betterleaks dir . -f json -r betterleaks.json
credactor --from-betterleaks betterleaks.json --fix-all --yes .
```
`--from-gitleaks` / `--from-trufflehog` / `--from-betterleaks` (ou une table `[ingest]` dans `.credactor.toml`) nécessitent une cible répertoire — pointez Credactor vers la même racine que celle sur laquelle le scanner a été exécuté. Les chemins des rapports sont résolus par rapport au répertoire de travail, et un rapport est un instantané : régénérez-le après avoir rédigé ou modifié l'arbre. Consultez le [guide d'intégration CI](https://github.com/rxb06/credactor/blob/main/docs/ci_integration.md).
## Plus de fonctionnalités
- Rédaction interactive ou par lots ; une chaîne de remplacement personnalisée via `--replacement` ; `--scan-history` pour scanner l'historique des commits git
- Sauvegardes sécurisées : `--secure-delete` (écrase et supprime le `.bak` ; élève la barre contre la récupération occasionnelle, pas une garantie forensique) ou `--secure-backup-dir` pour stocker les sauvegardes hors du dépôt
- Listes d'autorisation en ligne `# credactor:ignore` et `.credactorignore` (globs, `file:line`, littéraux de valeur)
- Configuration par dépôt via `.credactor.toml`
- 29 types de fichiers source/config/notes prêts à l'emploi (`.txt` inclus) ; `--scan-json` pour inclure JSON ; `--fail-on-error` pour échouer lorsqu'un fichier ne peut pas être lu
## Types de fichiers scannés
> `.py` `.js` `.ts` `.jsx` `.tsx` `.sh` `.bash` `.env` `.cfg` `.ini` `.toml` `.yaml` `.yml` `.rb` `.go` `.java` `.php` `.cs` `.kt` `.tf` `.hcl` `.conf` `.config` `.properties` `.xml` `.pem` `.key` `.crt` `.txt`
Plus les variantes `.env.*` / `.env-*` (`.env.local`, `.env.production`) et les fichiers SSH / clés privées (`id_rsa`, `id_dsa`, `id_ecdsa`, `id_ed25519`), tous reconnus par nom de fichier plutôt que par extension. JSON est exclu par défaut car les réponses d'API produisent un taux élevé de faux positifs ; ajoutez `--scan-json` pour l'inclure. Un fichier nommé directement sur la ligne de commande est scanné même si son extension ne figure pas dans cette liste.
## Codes de sortie
| Code | Signification |
|---|---|
| `0` | Aucun résultat, ou tous résolus |
| `1` | Résultats non résolus |
| `2` | Erreur (par exemple : mauvais chemin, `--replacement` dangereux, `--ci --fix-all`, un rapport d'ingestion manquant ou invalide, ou `--fail-on-error` avec un fichier illisible) |
## Durcissement de la chaîne d'approvisionnement
Un outil de sécurité doit être sûr à installer, pas seulement sûr à exécuter. Le pipeline de build et de release de Credactor est durci de bout en bout ; tous les détails dans le [document Sécurité](https://github.com/rxb06/credactor/blob/main/docs/security.md#supply-chain-hardening).
- **Zéro dépendance à l'exécution.** Un `pip install credactor` par défaut n'entraîne aucun paquet tiers (seulement l'extra optionnel `[encoding]`), donc il n'y a rien à vérifier à l'installation.
- **Chaîne d'outils épinglée par hachage.** Les builds CI et de release s'installent depuis un fichier de verrouillage `--require-hashes`, backend de build inclus (`python -m build --no-isolation` contre un ensemble setuptools épinglé), donc une dépendance altérée fait échouer le build.
- **Artefacts vérifiés octet par octet par rapport aux sources.** À chaque push et avant chaque publication, `scripts/audit_wheel.py` compare la wheel et la sdist aux sources committées octet par octet (sha256 vs `git HEAD`) ; tout fichier ajouté, manquant ou altéré fait échouer la barrière, donc une étape de build ne peut pas injecter du code sans être remarquée.
- **CI épinglée par SHA, à moindre privilège.** Les GitHub Actions sont épinglées à des SHA de commit, et les jetons de workflow restent étroits — `contents: read` par défaut, `id-token: write` uniquement pour le job de publication.
## Documentation
| Document | Description |
|----------|-------------|
| [Guide d'installation](https://github.com/rxb06/credactor/blob/main/docs/setup.md) | Installation, configuration, intégration CI/CD |
| [Manuel](https://github.com/rxb06/credactor/blob/main/docs/manual.md) | Référence complète : chaque option, mode et combinaison, comportement de remplacement et de sauvegarde, détection et sévérité, codes de sortie et limitations (comportement vérifié par tests) |
| [Exemples](https://github.com/rxb06/credactor/blob/main/docs/examples.md) | Flux de travail courants avec sortie |
| [Intégration CI](https://github.com/rxb06/credactor/blob/main/docs/ci_integration.md) | Hooks pre-commit, pipelines CI |
| [Sécurité](https://github.com/rxb06/credactor/blob/main/docs/security.md) | Modèle de menace, mesures de durcissement, limitations connues |
| [Journal des modifications](https://github.com/rxb06/credactor/blob/main/CHANGELOG.md) | Historique des versions |
| [Contribution](https://github.com/rxb06/credactor/blob/main/CONTRIBUTING.md) | Configuration de développement, style de code, processus de PR |
| [Avertissement](https://github.com/rxb06/credactor/blob/main/docs/DISCLAIMER.md) | Limitations, utilisation sûre, garantie |
## Licence
Apache 2.0. Voir [LICENSE](https://github.com/rxb06/credactor/blob/main/LICENSE).