Zurück zu den Updates
New releaseJul 22, 2026

secretlint v13.0.4

Erweiterbares Linting-Tool, um das Committen von Zugangsdaten zu verhindern.

Teilen

Secretlint Actions Status

Secretlint ist ein plug-in-fähiges Linting-Tool, um das Committen von Anmeldeinformationen zu verhindern.

Secretlint ist ein plug-in-fähiges Linting-Tool, um das Committen von Anmeldeinformationen zu verhindern.

Funktionen

  • Scanner: Findet Anmeldeinformationen in einem Projekt und meldet diese
  • Projektfreundlich: Einfach einzurichten in Ihr Projekt und zur Integration von CI-Diensten
  • Pre-Commit-Hook: Verhindert das Committen von Dateien mit Anmeldeinformationen
  • Pluggable: Ermöglicht die Erstellung eigener Regeln und flexible Konfiguration
  • Dokumentation: Beschreibt den Grund, warum eine Regel einen Geheimnis erkennt

Kurzdemo

Sie können das Linting-Ergebnis von Secretlint auf https://secretlint.github.io/ einsehen.

Schnellstart

Sie können Secretlint mit einem einzigen Befehl in Ihrem Projekt ausprobieren.

Falls Sie bereits Docker installiert haben:

docker run -v `pwd`:`pwd` -w `pwd` --rm -it secretlint/secretlint secretlint "**/*"

Falls Sie bereits Node.js installiert haben:

npx @secretlint/quick-start "**/*"

Nach der Ausführung: Wenn das Ergebnis leer ist und der Exit-Status 0 ist, ist Ihr Projekt sicher. Andernfalls erhalten Sie einen Fehlerbericht – Ihr Projekt enthält Anmeldeinformationen als Rohdaten.

Ein Beispiel für das Ergebnis von Secretlint

Sie möchten kontinuierliche Sicherheit? Dann folgen Sie der nachstehenden Installationsanleitung und richten Sie einen Pre-Commit-Hook sowie CI ein.

Installation

Mit Docker

Voraussetzungen: Sie benötigen Docker

Verwenden Sie unseren Docker-Container, um eine Umgebung mit Node.js und Secretlint so schnell wie möglich zu erhalten, wie Sie sie herunterladen können.

Sie können alle Dateien im aktuellen Verzeichnis mit Secretlint mit folgendem Befehl überprüfen:

docker run -v `pwd`:`pwd` -w `pwd` --rm -it secretlint/secretlint secretlint "**/*"

Der secretlint/secretlint Docker-Container funktioniert standardmäßig ohne Konfiguration.

Dieses Docker-Image enthält bereits installierte Pakete:

Weitere Details finden Sie in Secretlints Dockerfile.

Mit Node.js

Voraussetzungen: Sie benötigen Node.js 22+.

Secretlint ist in JavaScript geschrieben. Sie können Secretlint mit npm installieren:``` npm install secretlint @secretlint/secretlint-rule-preset-recommend --save-dev

Dann sollten Sie eine Konfigurationsdatei einrichten:```
npx secretlint --init

Schließlich können Sie Secretlint auf jeder Datei oder jedem Verzeichnis wie folgt ausführen:``` npx secretlint "**/*"

:memo: Secretlint unterstützt [Glob-Muster](https://github.com/mrmlnc/fast-glob#basic-syntax) und das Glob-Muster sollte in doppelte Anführungszeichen eingeschlossen werden.

Es ist auch möglich, Secretlint global mit `npm install --global` zu installieren. Wir empfehlen es jedoch nicht, da einige Regeln global beschädigt werden können.

### Verwendung einer einzelnen ausführbaren Binärdatei

**Voraussetzungen:** Keine

Sie können den `secretlint`-Befehl ohne Node.js verwenden, indem Sie eine einzelne ausführbare Binärdatei nutzen.

1. Laden Sie die neueste Binärdatei von der [Releases-Seite](https://github.com/secretlint/secretlint/releases) herunter.
2. Ändern Sie die Dateiberechtigung auf ausführbar: `chmod +x ./secretlint`
3. Führen Sie `./secretlint --init` aus, um eine Konfigurationsdatei zu erstellen.
4. Führen Sie `./secretlint "**/*"` aus, um Ihr Projekt zu überprüfen.

Weitere Einzelheiten finden Sie in der README von [publish/binary-compiler](https://github.com/secretlint/secretlint/blob/HEAD/publish/binary-compiler).

## Verwendung

`secretlint --help` zeigt die Verwendung an.

    Secretlint CLI that scan secret/credential data.
    
    Usage
    $ secretlint [file|glob*]
    
    Note
    supported glob syntax is based on picomatch (the engine used by micromatch)
    https://github.com/micromatch/picomatch#globbing-features
    https://github.com/micromatch/micromatch#matching-features
    
    Options
    --init             setup config file. Create .secretlintrc.json file from your package.json
    --format           [String] formatter name. Default: "stylish". Available Formatter: checkstyle, compact, github, jslint-xml, junit, pretty-error, stylish, tap, unix, json, mask-result, table
    --output           [path:String] output file path that is written of reported result.
    --secretlintrc     [path:String] path to .secretlintrc config file. Default: .secretlintrc.*
    --secretlintignore [path:String] path to .secretlintignore file. Default: .secretlintignore
    --stdinFileName    [String] filename to process STDIN content. Some rules depend on filename to check content.
    --no-color         disable ANSI-color of output.
    --no-terminalLink  disable terminalLink of output.
    --no-maskSecrets   disable masking of secret values; secrets are masked by default.
    --no-glob          disable glob pattern interpretation; treat all inputs as literal file paths.
    --no-gitignore     disable .gitignore cascade respect; .gitignore files are
                       respected by default (since v13).
    
    Options for Developer
    --profile          Enable performance profile.
    --secretlintrcJSON [String] a JSON string of .secretlintrc. use JSON string instead of rc file.
    
    Experimental Options
    --locale            [String] locale tag for translating message. Default: en
    
    Examples
    # Scan a single file
    $ secretlint ./README.md

    # Scan all files (wrap glob in double quotes to avoid shell expansion)
    $ secretlint "**/*"
    $ secretlint "source/**/*.ini"

    # Treat inputs as literal paths (for SvelteKit (group) / Next.js [param] etc.)
    $ secretlint --no-glob "src/(auth)/login.ts"

    # Lint STDIN content (filename hint affects which rules apply)
    $ echo "SECRET" | secretlint --stdinFileName=secret.txt

    # Use a custom config file
    $ secretlint "**/*" --secretlintrc=.secretlintrc.custom.json

    # Scan files ignored by .gitignore (e.g. to verify build artifacts)
    $ secretlint --no-gitignore "dist/**/*"

    # Mask secrets in a file in-place
    $ secretlint .zsh_history --format=mask-result --output=.zsh_history

    # Output JSON for programmatic parsing
    $ secretlint "**/*" --format=json --output=secretlint-report.json

    # Output GitHub Actions annotations in CI
    $ secretlint "**/*" --format=github
    
    Exit Status
    Secretlint exits with the following values:
    
        - 0:
          - Linting succeeded, no errors found.
          - Found lint error but --output is specified.
        - 1:
          - Linting failed, errors found.
        - 2:
          - Unexpected error occurred, fatal error.

## Konfiguration

Secretlint hat eine Konfigurationsdatei `.secretlintrc.{json,yml,js}`.

- Dokumentation: [Secretlint konfigurieren](https://github.com/secretlint/secretlint/blob/HEAD/docs/configuration.md)

Nachdem Sie `secretlint --init` ausgeführt haben, haben Sie eine `.secretlintrc.json`-Datei in Ihrem Verzeichnis.

Darin sehen Sie einige Regeln, die wie folgt konfiguriert sind:```json
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-preset-recommend"
    }
  ]
}

Die id-Eigenschaft ist der Name des secretlint-Regelpakets.

Secretlint hat keine integrierte Regel. Sie möchten eine Regel hinzufügen und sollten das Paket installieren und die Regel zur .secretlintrc-Datei hinzufügen.

Jede Regel hat das gleiche Konfigurationsmuster:

  • options: Optionsdefinition für die Regel. Weitere Einzelheiten finden Sie in der jeweiligen Regeldokumentation
  • disabled: Wenn disabled auf true gesetzt ist, wird die Regel deaktiviert
  • allowMessageIds: allowMessageIds ist ein Array von Nachrichten-IDs, deren Fehlerberichterstattung Sie unterdrücken möchten
    • Nachrichten-ID ist in jeder Regel definiert; bitte lesen Sie die Regeldokumentation

Beispiel: options

Zum Beispiel hat @secretlint/secretlint-rule-example allows in options. Diese allows-Option definiert eine Liste von RegExp-ähnlichen Zeichenfolgen, die Sie ignorieren möchten.```json { "rules": [ { "id": "@secretlint/secretlint-rule-example", "options": { "allows": [ "/dummy_secret/i" ] } } ] }

Wenn du ein Preset wie `@secretlint/secretlint-rule-preset-recommend` verwendest, musst du die Option in `rules` angeben.

Zum Beispiel eine Option für `@secretlint/secretlint-rule-preset-recommend > @secretlint/secretlint-rule-aws````json5
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-preset-recommend",
      "rules": [
        {
          "id": "@secretlint/secretlint-rule-aws",
            "options": {
              "allows": [
	            // it will be ignored
                "xxxx-xxxx-xxxx-xxxx-xxxx"
              ]
            }
        }
      ]
    }
  ]
}

Beispiel: allowMessageIds

Zum Beispiel haben Sie folgenden Fehlerbericht durch Ausführen von secretlint erhalten:``` $ secretlint "**/*"

SECRET.txt 1:8 error [EXAMPLE_MESSAGE] found secret: SECRET @secretlint/secretlint-rule-example

✖ 1 problem (1 error, 0 warnings)

Die Nachrichten-ID dieses Fehlers ist `EXAMPLE_MESSAGE` in `@secretlint/secretlint-rule-example`. Wenn Sie diesen Fehler ignorieren möchten, verwenden Sie bitte `allowMessageIds`.```json
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-example",
      "allowMessageIds": ["EXAMPLE_MESSAGE"]
    }
  ]
}

Wenn Sie ein Preset wie @secretlint/secretlint-rule-preset-recommend verwenden, müssen Sie die Option in rules setzen.

Zum Beispiel, wenn Sie "AWSAccountID" und "AWSAccessKeyID" von "@secretlint/secretlint-rule-aws" ignorieren möchten, können Sie Folgendes schreiben.

{
    "rules": [
        {
            "id": "@secretlint/secretlint-rule-aws",
            "rules": [
                {
                    "id": "@secretlint/secretlint-rule-preset-recommend",
                    "options": {
                        "ignores": ["AWSAccountID", "AWSAccessKeyID"]
                    }
                }
            ]
        }
    ]
}
``````json5
{
  "rules": [
    {
      "id": "@secretlint/secretlint-rule-preset-recommend",
      "rules": [
        {
          "id": "@secretlint/secretlint-rule-aws",
          "allowMessageIds": ["AWSAccountID", "AWSAccessKeyID"]
        }
      ]
    }
  ]
}

Ignorieren von Dateien mittels .gitignore und .secretlintignore

Secretlint durchläuft das Dateisystem auf die gleiche Weise wie Git und beachtet dabei verschachtelte .gitignore-Dateien. Eine Datei oder ein Verzeichnis, das von einer .gitignore-Datei auf dem Pfad vom Arbeitsverzeichnis zur Datei abgeglichen wird, wird übersprungen.

.secretlintignore funktioniert auf die gleiche Weise wie .gitignore und wird zusätzlich herangezogen. Die Auflösungsreihenfolge ist:

  1. Integrierte Ignorierungen: .git, node_modules, und die .secretlintrc*-Familie.
  2. Die Datei, auf die --secretlintignore verweist (Standard: .secretlintignore).
  3. Die .gitignore jedes Verzeichnisses (kaskadiert).

Um Dateien zu scannen, die gitignoriert sind — zum Beispiel eine .env-Datei in einem Projekt, in dem .env gitignoriert ist — verwenden Sie --no-gitignore:``` secretlint --no-gitignore "**/*"

> **Migration zu v13:**
> - `.gitignore` wird nun standardmäßig respektiert. Bisher hat secretlint alle passenden Dateien unabhängig von `.gitignore` gescannt. Verwenden Sie `--no-gitignore`, um das vorherige Verhalten wiederherzustellen.
> - Include-Muster folgen der Picomatch-Glob-Syntax (Brace-Expansion, `**`, Zeichenklassen, …). Der kaskadierte Ignore-Stack (`.gitignore`, `.secretlintignore` und die integrierte Ignore-Liste) folgt der Standard-`.gitignore`-Semantik, die KEINE Brace-Expansion unterstützt — schreiben Sie `**/.cache` anstelle von `**/{cache,tmp}` für Ignore-Muster.
> - Muster werden standardmäßig als Globs interpretiert. Wenn ein Muster einem vorhandenen Pfad auf der Festplatte entspricht, behandelt der Walker es wörtlich, selbst wenn der Name Glob-Metazeichen (`[`, `(`, `{`, `?`) enthält, was dem alten `convertPathToPattern`-Verhalten von globby entspricht. Verwenden Sie `--no-glob`, um die wörtliche Behandlung für Pfade zu erzwingen, die noch nicht auf der Festplatte existieren.
> - Verzeichnis-Symlinks werden während der Suche verfolgt (entsprechend dem vorherigen globby-basierten Verhalten), aber der Symlink-Pfad — nicht das aufgelöste Ziel — wird von den `.gitignore`- und `.secretlintignore`-Regeln gesehen. Zyklen werden über `realpath` erkannt, sodass jedes eindeutige Ziel höchstens einmal betreten wird.

### Ignorieren durch Kommentar

[@secretlint/secretlint-rule-filter-comments](https://www.npmjs.com/package/@secretlint/secretlint-rule-filter-comments) unterstützt das Ignorieren von Kommentaren wie `secretlint-disable`.```
// secretlint-disable

THIS IS SECRET, BUT IT WILL BE IGNORED

// secretlint-enable

Für weitere Details siehe Konfigurieren von Secretlint.

Anwendungsfälle

Geheimnisse in Lint-Fehlermeldungen maskieren (Standardverhalten)

Secretlint maskiert standardmäßig Geheimnisse in Lint-Fehlermeldungen. Dies ist nützlich, um versehentliches Offenlegen von Geheimnissen in CI-Protokollen, Terminalausgaben oder bei Verwendung von KI-Agenten-Tools zu verhindern.```bash

Secrets are masked by default

$ secretlint "**/*"

Um die tatsächlichen Geheimniswerte in der Ausgabe anzuzeigen, verwenden Sie `--no-maskSecrets`:```bash
$ secretlint --no-maskSecrets "**/*"

Geheimnisse beheben

Secretlint kann die Geheimnisse nicht automatisch beheben. Es ist jedoch nützlich, dass --format=mask-result die Geheimnisse der Eingabedatei maskiert.

Beispielsweise können Sie die Geheimnisse der Datei .zsh_history maskieren und überschreiben.```bash $ secretlint .zsh_history --format=mask-result --output=.zsh_history

## Regelpakete

Secretlint-Regeln wurden als separate Module implementiert.

- [@secretlint/secretlint-rule-npm](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-npm)
- [@secretlint/secretlint-rule-aws](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-aws)
- [@secretlint/secretlint-rule-gcp](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-gcp)
- [@secretlint/secretlint-rule-github](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-github)
- [@secretlint/secretlint-rule-gitlab](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-gitlab)
- [@secretlint/secretlint-rule-privatekey](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-privatekey)
- [@secretlint/secretlint-rule-basicauth](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-basicauth)
- [@secretlint/secretlint-rule-slack](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-slack)
- [@secretlint/secretlint-rule-sendgrid](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-sendgrid)
- [@secretlint/secretlint-rule-shopify](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-shopify)
- [@secretlint/secretlint-rule-stripe](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-stripe)
- [@secretlint/secretlint-rule-openai](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-openai)
- [@secretlint/secretlint-rule-anthropic](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-anthropic)
- [@secretlint/secretlint-rule-grafana](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-grafana)
- [@secretlint/secretlint-rule-groq](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-groq)
- [@secretlint/secretlint-rule-linear](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-linear)
- [@secretlint/secretlint-rule-1password](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-1password)
- [@secretlint/secretlint-rule-database-connection-string](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-database-connection-string)
- [@secretlint/secretlint-rule-databricks](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-databricks)
- [@secretlint/secretlint-rule-hashicorp-vault](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-hashicorp-vault)
- [@secretlint/secretlint-rule-vercel](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-vercel)
- [@secretlint/secretlint-rule-azure](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-azure)
- [@secretlint/secretlint-rule-docker](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-docker)
- [@secretlint/secretlint-rule-figma](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-figma)
- [@secretlint/secretlint-rule-cloudflare](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-cloudflare)
- [@secretlint/secretlint-rule-tailscale](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-tailscale)
- [@secretlint/secretlint-rule-huggingface](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-huggingface)
- [@secretlint/secretlint-rule-notion](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-notion)
- [@secretlint/secretlint-rule-secp256k1-privatekey](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-secp256k1-privatekey)
- [@secretlint/secretlint-rule-no-k8s-kind-secret](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-no-k8s-kind-secret)
- [@secretlint/secretlint-rule-pattern](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-pattern)
- [@secretlint/secretlint-rule-no-homedir](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-no-homedir)
- [@secretlint/secretlint-rule-no-dotenv](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-no-dotenv)
- [@secretlint/secretlint-rule-filter-comments](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-filter-comments)

Außerdem stellt Secretlint ein Regelpaket (Preset) bereit, das die empfohlenen Regeln enthält.

- [@secretlint/secretlint-rule-preset-recommend](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-rule-preset-recommend)
    - Empfohlenes Regelset

## Benutzerdefinierte Regeln

Sie können eigene Secretlint-Regeln erstellen.

Sie möchten eine für Ihr Projekt geeignete Secretlint-Regel? Sie können sie erstellen!
Eine Secretlint-Regel ist einfach ein npm-Paket.

Wenn Sie erfahren möchten, wie Sie eine Secretlint-Regel erstellen, lesen Sie bitte [docs/secretlint-rule.md](https://github.com/secretlint/secretlint/blob/HEAD/docs/secretlint-rule.md).

## Integrationen

### Pre-Commit-Hook pro Projekt

Sie können Secretlint mit einem Pre-Commit-Tool verwenden.
So können Sie verhindern, dass Geheimdaten durch Linting mit Secretlint committet werden.

Wenden Sie Secretlint auf das Projekt an und verbessern Sie die Sicherheit bei der Teamentwicklung.

#### [Husky](https://github.com/typicode/husky) + [lint-staged](https://github.com/okonet/lint-staged)

**Anwendungsfall:** Wenn Sie Secretlint in ein Node.js-Projekt einführen möchten, ist diese Kombination nützlich.

Installieren Sie [Husky](https://github.com/typicode/husky) und [lint-staged](https://github.com/okonet/lint-staged):```
npx husky-init && npm install lint-staged --save-dev

Füge Hooks zu .husky/pre-commit hinzu:``` npx husky add .husky/pre-commit "npx --no-install lint-staged"

Bearbeiten `package.json`:```json5
{
  // add "lint-staged" field
  "lint-staged": {
    "*": [
      "secretlint --no-glob"
    ]
  }
}

Hinweis: Das Flag --no-glob ist erforderlich, da lint-staged literale Dateipfade übergibt, die möglicherweise spezielle Glob-Zeichen enthalten (z. B. (group) oder [param] Routing-Muster, die von Next.js, SvelteKit usw. verwendet werden).

Das bedeutet, dass jede gestagte Datei vor dem Commit von Secretlint überprüft wird.

pre-commit

Anwendungsfall: Sie haben ein Projekt, das mit Docker entwickelt wird. Einfach in secretlint zu integrieren.

Installieren Sie pre-commit

# macOS. Siehe auch https://pre-commit.com/#install
brew install pre-commit

Erstellen Sie .pre-commit-config.yaml:```

  • repo: local hooks:
    • id: secretlint name: secretlint language: docker_image entry: secretlint/secretlint:latest secretlint
Beispiel-Setup-Repository:

- https://github.com/azu/secretlint-pre-commit-example

#### Bash-Skript

Alternativ können Sie dieses Skript als `.git/hooks/pre-commit` speichern und ihm Ausführungsberechtigung erteilen (`chmod +x .git/hooks/pre-commit`):```bash
#!/bin/sh
FILES=$(git diff --cached --name-only --diff-filter=ACMR | sed 's| |\\ |g')
[ -z "$FILES" ] && exit 0

# Secretlint all selected files
echo "$FILES" | xargs ./node_modules/.bin/secretlint --no-glob
# If you using docker
# echo "$FILES" | xargs docker run -v `pwd`:`pwd` -w `pwd` --rm secretlint/secretlint secretlint
RET=$?
if [ $RET -eq 0 ] ;then
    exit 0
else
    exit 1
fi

Pre-commit-Hook global

Anwendungsfall: Wenn Sie jedes Projekt mit secretlint überprüfen möchten, können Sie globale Git-Hooks verwenden.

Git 2.9+ unterstützt core.hooksPath. Es ermöglicht die Integration von secretlint global.

Wir haben ein Beispiel-Git-Hooks-Projekt mit secretlint + Docker erstellt.

Sie können es mit den folgenden Schritten einrichten:```shell script

clone this repository

git clone https://github.com/secretlint/git-hooks git-hooks cd git-hooks

integrate secretlint to git hook globally

git config --global core.hooksPath $(pwd)/hooks

Nach der Einrichtung von `core.hooksPath` prüft secretlint jede Datei, bevor Sie sie committen.  

Weitere Einzelheiten finden Sie im Projekt [secretlint/git-hooks](https://github.com/secretlint/git-hooks).

Die Node.js-Version kann auch für globale Git-Hooks verwendet werden.
Wenn Sie daran interessiert sind, sehen Sie sich bitte [@azu/git-hooks](https://github.com/azu/git-hooks) an.

### CI

#### GitHub Actions

Wenn Sie secretlint bereits [mit Node.js](#using-nodejs) eingerichtet haben, können Sie secretlint mit Ihrer Konfiguration in [GitHub Actions](https://github.co.jp/features/actions) ausführen.

Legen Sie `.github/workflows/secretlint.yml` in Ihrem Repository ab.```yaml
name: Secretlint
on: [push, pull_request]
permissions:
  contents: read
jobs:
  test:
    name: "Secretlint"
    runs-on: ubuntu-latest
    steps:
      - name: checkout
        uses: actions/checkout@v3
      - name: setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 22
      - name: Install
        run: npm ci
      - name: Lint with Secretlint
        run: npx secretlint "**/*"
--format github für Pull-Request-Anmerkungen

Sie können --format github verwenden, um Lint-Fehler als Anmerkungen auf Pull-Request-Dateien anzuzeigen. Dieser Formatierer gibt GitHub Actions workflow commands aus, die Fehleranmerkungen direkt auf den geänderten Dateien in Ihrem Pull-Request anzeigen.```yaml - name: Lint with Secretlint run: npx secretlint --format github "**/*"

Diese Konfiguration integriert Pull-Request-Review-Anmerkungen.

![github-actions.png](https://assets.kitploit.com/production/public/readmes/6649/c4558d395907512504eb827499bbb28e442b4dd57164ca6bd64b836a0e2988eb.png)

- Beispiel-Repository: https://github.com/secretlint/secretlint-github-actions-example
- Beispiel-Pull-Request: https://github.com/secretlint/secretlint-github-actions-example/pull/1/files

Wenn Sie nur Diff-Dateien überprüfen möchten, siehe folgendes Beispiel:```yaml
name: test-diff
on:
  push:
  pull_request:
jobs:
  test-diff:
    permissions:
      contents: read
    name: "Run secretlint to diff files"
    runs-on: ubuntu-latest
    steps:
      - name: checkout
        uses: actions/checkout@v4
        with:
          # fetch history to get all changed files on push or pull_request event
          fetch-depth: 0
      - name: Get changed files
        id: changed-files
        uses: tj-actions/changed-files@v44
        with:
          quotepath: "false"
      - name: setup Node ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: 22
      - name: Show changed files
        run: echo "${{ steps.changed-files.outputs.all_changed_files }}"
      - name: Install
        if: steps.changed-files.outputs.any_changed == 'true'
        run: npm ci
      - name: Run secretlint
        if: steps.changed-files.outputs.any_changed == 'true'
        run: npx secretlint --no-glob ${{ steps.changed-files.outputs.all_changed_files }}

Mega-Linter

Mega-Linter ist ein Linter-Aggregator, der nativ mit jedem CI-Tool kompatibel ist und standardmäßig 80+ Linting-Apps sowie secretlint enthält.

Sie können es mit dem folgenden Befehl in jedem Repository-Projekt installieren (Node.js muss zuvor installiert sein).```shell npx mega-linter-runner --install

![megalinter-secretlint-failure.png](https://assets.kitploit.com/production/public/readmes/6649/3db15386c6559c762029a095a5f3c0d83bb55255d261809254296d55fa6d6748.png)

### Browser

[Secretlint WebExtension](https://github.com/secretlint/webextension) funktioniert in Ihrem Browser.

- Firefox: <https://addons.mozilla.org/ja/firefox/addon/secretlint/>
- Chrome: <https://chrome.google.com/webstore/detail/secretlint/hidpojbnemkajlnibhmeilpgoddkjjkf>

Diese Web-Erweiterung zielt darauf ab, Anmeldeinformationen zu finden, die in Ihrer Anfrage/Antwort enthalten sind.

![Secretlint WebExtension](https://assets.kitploit.com/production/public/readmes/6649/ecb458b32d60007d85b13d2c238cb235e0ac856c7cbea6590fde520e3bcf07f0.png)

Secretlint WebExtension integriert sich in die DevTools von Chrome/Firefox.
Diese Erweiterung hilft Webentwicklern, offengelegte Anmeldeinformationen zu bemerken.

### macOS

[SecureClipboard](https://github.com/secretlint/secure-clipboard) ist eine macOS-Menüleistenanwendung, die Secretlint verwendet, um Geheimnisse in Ihrer Zwischenablage zu erkennen und zu maskieren, bevor sie an anderer Stelle eingefügt werden.

### Sonstiges

#### Unterstützung des SARIF-Formats

Bitte verwenden Sie [@secretlint/secretlint-formatter-sarif](https://github.com/secretlint/secretlint/blob/HEAD/packages/@secretlint/secretlint-formatter-sarif).```
npm install @secretlint/secretlint-formatter-sarif --dev
secretlint --format @secretlint/secretlint-formatter-sarif "**/*"

Semantic Versioning Policy

Secretlint project follows Semantic Versioning(secretlint-rule-preset-canary is an exception).

  • Patch release (intended to not break your lint build)
    • A bug fix to the CLI or core (including formatters).
    • Improvements to documentation.
    • Non-user-facing changes such as refactoring.
    • Re-releasing after a failed release (i.e., publishing a release that doesn't work for anyone).
  • Minor release (might break your lint build)
    • A new option.
    • An existing rule is deprecated.
    • A new CLI capability is created.
    • New public API are added (new classes, new methods, new arguments to existing methods, etc.).
      • It might break TypeScript definitions
    • A new formatter is created.
  • Major release (break your lint build)
    • A new option to an existing rule that results in secretlint reporting more errors by default.
    • An existing formatter is removed.
    • Add new default rule to rule preset.
    • Part of the public API is removed or changed in an incompatible way.

Motivation

Philosophy

  • Reduce false-positive of linting
  • Integration to developing workflow
  • Empower Users to Contribute

Opt-in instead of Opt-out

Secretlint adopt opt-in approach.

In our experience, linting tools that report various errors by default are difficult to use. Opt-in approach helps to introduce Secretlint incrementally.

It will help to reduce false-positive by configuration.

Rule as Documentation

We think a rule as a documentation. So, Each rule should have reasonable documentation.

We need to describe why this file is error. A rule that has no documentation is just opinionated.

Describe the reason of error and then it will lead to reduce false-positive error.

Also, Secretlint CLI support hyperlink in Terminal. It means that you can jump to rule documentation from lint error message directly.

clickable link in output

Example on iTerm 2: Cmd + Click error's messageId and open AWSSecretAccessKey on your browser.

If you want to know support terminal, please see Hyperlinks in Terminal Emulators.

Also, Welcome to Contribution about secretlint documentation!

Why Node.js?

  • Package Manager
    • Require package manager to realize flexible pluggable system
    • Node.js has npm and pnpm as package manager
    • Package manager help to install custom plugin/rule by user
  • Exist Reference Implementation
    • Node.js already has pluggable linting tools like ESLint, textlint, stylelint etc
    • So Node.js users are familiar with pluggable linting tools
    • Previously, I created textlint with the same approach, so I am familiar with Node.js
  • Users
    • JavaScript is a popular language
    • It empowers users to contribute
    • Users can create own rule by own hand

Of course, secretlint also support Docker.

Changelog

See Releases page.

Contributing

Pull requests and stars are always welcome.

For bugs and feature requests, please create an issue.

See also, CONTRIBUTING.md and CODE_OF_CONDUCT.md

Add New Rule

You can use pnpm run gen:rule command to create new rule.```shell script pnpm run gen:rule

Für weitere Details lesen Sie bitte [CONTRIBUTING.md](https://github.com/secretlint/secretlint/blob/HEAD/CONTRIBUTING.md)

### Benchmark

Der Benchmark-Workflow wird bei jedem Commit ausgeführt.

- Benchmark: https://secretlint.github.io/secretlint/dev/bench/

## Autor

- [github/azu](https://github.com/azu)
- [twitter/azu_re](https://twitter.com/azu_re)

## Lizenz

MIT © azu
Mehr lesen

Kategorien

Statische AnalyseCode-AnalyseDevSecOpsSecret-Erkennung