gosec - Go-Sicherheitsprüfer

Untersucht Quellcode auf Sicherheitsprobleme durch Scannen der Go AST- und SSA-Code-Darstellung.

Kurzlinks

• GitHub Action
• Lokale Installation
• Schnellstart
• Häufige Verwendungsmuster
• Regeln auswählen
• Ausgabeformate

Funktionen

• Musterbasierte Regeln zum Erkennen häufiger Sicherheitsprobleme in Go-Code
• SSA-basierte Analysatoren für Typumwandlungen, Slice-Grenzen und Krypto-Probleme
• Taint-Analyse zur Verfolgung des Datenflusses von Benutzereingaben zu gefährlichen Funktionen (SQL-Injection, Command-Injection, Path Traversal, SSRF, XSS, Log-Injection, SMTP-Injection, SSTI, unsichere Deserialisierung, Open Redirect)

Lizenz

Lizenziert unter der Apache License, Version 2.0 (der "Lizenz"). Sie dürfen diese Datei nur in Übereinstimmung mit der Lizenz verwenden. Eine Kopie der Lizenz erhalten Sie hier.

Projektstatus

Installation

GitHub Action

Sie können gosec wie folgt als GitHub Action ausführen:

Verwenden Sie den versionierten Tag mit @master, der auf die neueste stabile Version festgelegt ist. Dies bietet ein stabiles Verhalten.```yaml name: Run Gosec on: push: branches: - master pull_request: branches: - master jobs: tests: runs-on: ubuntu-latest env: GO111MODULE: on steps: - name: Checkout Source uses: actions/checkout@v3 - name: Run Gosec Security Scanner uses: securego/gosec@master with: args: ./...

#### Scannen von Projekten mit privaten Modulen

Wenn Ihr Projekt private Go-Module importiert, müssen Sie die Authentifizierung konfigurieren, damit `gosec` die Abhängigkeiten abrufen kann. Setzen Sie die folgenden Umgebungsvariablen in Ihrem Workflow:

- `GOPRIVATE`: Eine kommagetrennte Liste von Modulpfad-Präfixen, die als privat betrachtet werden sollen (z.B. `github.com/your-org/*`).
- `GITHUB_AUTHENTICATION_TOKEN`: Ein GitHub-Token mit Lesezugriff auf Ihre privaten Repositorys.```yaml
name: Run Gosec
on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
jobs:
  tests:
    runs-on: ubuntu-latest
    env:
      GO111MODULE: on
      GOPRIVATE: github.com/your-org/*
      GITHUB_AUTHENTICATION_TOKEN: ${{ secrets.PRIVATE_REPO_TOKEN }}
    steps:
      - name: Checkout Source
        uses: actions/checkout@v3
      - name: Run Gosec Security Scanner
        uses: securego/gosec@v2
        with:
          args: ./...

Integration mit Code-Scanning

Sie können Tools zur Code-Analyse von Drittanbietern integrieren in das GitHub-Code-Scanning, indem Sie Daten als SARIF-Dateien hochladen.

Der Workflow zeigt ein Beispiel für die Ausführung von gosec als Schritt in einem GitHub Actions-Workflow, der die Datei results.sarif ausgibt. Der Workflow lädt dann die Datei results.sarif auf GitHub hoch, indem er die Aktion upload-sarif verwendet.```yaml name: "Security Scan"

Run workflow each time code is pushed to your repository and on a schedule.

The scheduled workflow runs every at 00:00 on Sunday UTC time.

on: push: schedule:

• cron: '0 0 * * 0'

jobs: tests: runs-on: ubuntu-latest env: GO111MODULE: on steps: - name: Checkout Source uses: actions/checkout@v3 - name: Run Gosec Security Scanner uses: securego/gosec@v2 with: # we let the report trigger content trigger a failure using the GitHub Security features. args: '-no-fail -fmt sarif -out results.sarif ./...' - name: Upload SARIF file uses: github/codeql-action/upload-sarif@v2 with: # Path to SARIF file relative to the root of the repository sarif_file: results.sarif

### Go Analyse

Das Paket `goanalysis` bietet einen
[`golang.org/x/tools/go/analysis.Analyzer`](https://pkg.go.dev/golang.org/x/tools/go/analysis)
zur Integration mit Werkzeugen, die die standardmäßige Go-Analyse-Schnittstelle unterstützen, wie z.B. Bazels
[nogo](https://github.com/bazelbuild/rules_go/blob/master/go/nogo.rst)
Framework:```starlark
nogo(
    name = "nogo",
    deps = [
        "@com_github_securego_gosec_v2//goanalysis",
        # add more analyzers as needed
    ],
    visibility = ["//visibility:public"],
)

Lokale Installation

gosec benötigt Go 1.25 oder neuer.```bash go install github.com/securego/gosec/v2/cmd/gosec@latest

## Schnellstart```bash
# Scan all packages in current module
gosec ./...

# Write JSON report
gosec -fmt json -out results.json ./...

# Write SARIF report for code scanning
gosec -fmt sarif -out results.sarif ./...

Exitcodes

• 0: Scan abgeschlossen ohne ununterdrückte Funde/Fehler
• 1: mindestens ein ununterdrückter Fund oder Verarbeitungsfehler
• Verwenden Sie -no-fail, um immer 0 zurückzugeben

Usage

Gosec kann so konfiguriert werden, dass nur eine Teilmenge der Regeln ausgeführt wird, bestimmte Dateipfade ausgeschlossen werden und Berichte in verschiedenen Formaten erstellt werden. Standardmäßig werden alle Regeln gegen die angegebenen Eingabedateien ausgeführt. Für eine rekursive Suche ab dem aktuellen Verzeichnis können Sie ./... als Eingabeargument angeben.

Verfügbare Regeln

gosec umfasst Regeln aus diesen Kategorien:

• G1xx: allgemeine Probleme sicherer Codierung (z. B. hartcodierte Anmeldeinformationen, unsichere Verwendung, HTTP-Härtung, Cookie-Sicherheit)
• G2xx: Injektionsrisiken bei der Erstellung von Abfragen/Vorlagen/Befehlen
• G3xx: Risiken bei der Datei- und Pfadverarbeitung (Berechtigungen, Traversal, temporäre Dateien, Archiv-Extraktion)
• G4xx: Krypto- und TLS-Schwächen
• G5xx: blockierte Importe
• G6xx: Go-spezifische Korrektheits-/Sicherheitsprüfungen (z. B. Range-Aliasing und Slice-Grenzen)
• G7xx: Taint-Analyse-Regeln (SQL-Injection, Command-Injection, Path Traversal, SSRF, XSS, Log, SMTP-Injection, SSTI, unsichere Deserialisierung und Open Redirect)

Die vollständige Liste, Regelbeschreibungen und die Konfiguration pro Regel finden Sie in RULES.md.

Ausgemusterte Regeln

• G105: Überprüfung der Verwendung von math/big.Int.Exp - CVE wurde behoben
• G307: Verzögern einer Methode, die einen Fehler zurückgibt - verursacht mehr Unannehmlichkeiten als die Behebung eines Sicherheitsproblems, trotz der Details in diesem Blogbeitrag

Regeln auswählen

Standardmäßig führt gosec alle Regeln gegen die angegebenen Dateipfade aus. Es ist jedoch möglich, eine Teilmenge der Regeln über das Flag -include= auszuwählen oder eine Reihe von Regeln explizit über das Flag -exclude= auszuschließen.```bash

Run a specific set of rules

$ gosec -include=G101,G203,G401 ./...

Run everything except for rule G303

$ gosec -exclude=G303 ./...

### CWE-Zuordnung

Jeder von `gosec` erkannte Befund wird einer
[CWE (Common Weakness Enumeration)](http://cwe.mitre.org/data/index.html)
zugeordnet, welche die Schwachstelle in allgemeineren Begriffen beschreibt. Die
genaue Zuordnung ist
[hier](https://github.com/securego/gosec/blob/master/issue/issue.go#L50) zu finden.

### Konfiguration

Eine Reihe globaler Einstellungen können in einer Konfigurationsdatei wie folgt bereitgestellt werden:```JSON
{
    "global": {
        "nosec": "enabled",
        "audit": "enabled"
    }
}

• nosec: diese Einstellung überschreibt alle #nosec-Direktiven, die im gesamten Codebase definiert sind
• audit: läuft im Audit-Modus, der zusätzliche Überprüfungen ermöglicht, die für die normale Codeanalyse zu aufdringlich sein könnten```bash

Run with a global configuration file

$ gosec -conf config.json .

### Pfadbasierte Regelausschlüsse

Große Repositorys mit mehreren Komponenten benötigen möglicherweise unterschiedliche Sicherheitsregeln für verschiedene Pfade. Verwenden Sie `exclude-rules`, um bestimmte Regeln für bestimmte Pfade zu unterdrücken.

**Konfigurationsdatei:**```json
{
  "exclude-rules": [
    {
      "path": "cmd/.*",
      "rules": ["G204", "G304"]
    },
    {
      "path": "scripts/.*",
      "rules": ["*"]
    }
  ]
}

CLI Flag:```bash

Exclude G204 and G304 from cmd/ directory

gosec --exclude-rules="cmd/.*:G204,G304" ./...

Exclude all rules from scripts/ directory

gosec --exclude-rules="scripts/.:" ./...

Multiple exclusions

gosec --exclude-rules="cmd/.:G204,G304;test/.:G101" ./...

| Feld | Typ | Beschreibung |
|-------|------|-------------|
| `path` | string (regex) | Regex, das auf Dateipfade angewendet wird |
| `rules` | []string | Regel-IDs, die ausgeschlossen werden sollen. `*` für alle |

#### Regelkonfiguration

Einige Regeln akzeptieren auch Konfigurationsflags; diese Flags sind in
[RULES.md](https://github.com/securego/gosec/blob/master/RULES.md) dokumentiert.

#### Go-Version

Einige Regeln erfordern eine bestimmte Go-Version, die aus der im Projekt vorhandenen Go-Moduldatei abgerufen wird. Wenn diese Version nicht gefunden werden kann, wird auf die Go-Laufzeitversion zurückgegriffen.

Die Go-Modulversion wird mit dem Befehl `go list` geparst, was in manchen Fällen zu Leistungseinbußen führen kann. In diesem Fall kann die Go-Modulversion einfach durch Setzen der Umgebungsvariablen `GOSECGOVERSION=go1.21.1` bereitgestellt werden.

### Abhängigkeiten

gosec lädt Pakete mit Go-Modulen. In den meisten Projekten werden Abhängigkeiten während der Überprüfung automatisch aufgelöst.

Wenn Abhängigkeiten fehlen, führen Sie Folgendes aus:```bash
go mod tidy
go mod download

Excluding test files and folders

gosec ignoriert Testdateien in allen Paketen und Abhängigkeiten in Ihrem vendor-Verzeichnis.

Das Scannen von Testdateien kann mit dem folgenden Flag aktiviert werden:```bash gosec -tests ./...

Auch zusätzliche Ordner können wie folgt ausgeschlossen werden:```bash
 gosec -exclude-dir=rules -exclude-dir=cmd ./...

Ausgeschlossene generierte Dateien

gosec kann generierte Go-Dateien mit dem standardmäßigen generierten Code-Kommentar ignorieren.``` // Code generated by some generator DO NOT EDIT.

Bitte fügen Sie den zu übersetzenden Markdown-Inhalt ein.```bash
gosec -exclude-generated ./...

Automatische Behebung von Schwachstellen

gosec kann basierend auf KI-Empfehlungen Korrekturen vorschlagen. Es ruft eine KI-API auf, um einen Vorschlag für einen Sicherheitsfund zu erhalten.

Sie können diese Funktion aktivieren, indem Sie die folgenden Kommandozeilenargumente angeben:

• ai-api-provider: der Name des KI-API-Anbieters. Unterstützte Anbieter:
  • Atlas Cloud: atlas (Standardmodell deepseek-ai/deepseek-v4-flash), atlas-deepseek-v4-flash, atlas-qwen3-coder-next, atlas-kimi-k2.6 oder atlas:<model-id> für jedes von Atlas Cloud gehostete Chat-Modell. Atlas Cloud ist ein OpenAI-kompatibler Anbieter, verfügbar unter atlascloud.ai
  • Gemini: gemini-3-pro-preview (Standard), gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite
  • Claude: claude-sonnet-4-6 (Standard), , , , ,

🎁 Atlas Cloud ist eine vollmodale KI-Inferenzplattform, die Entwicklern eine einzige KI-API bietet, um auf Videogenerierung, Bildgenerierung und LLM-APIs zuzugreifen. Anstatt mehrere Anbieterintegrationen zu verwalten, verbinden Sie sich einmal und erhalten einheitlichen Zugriff auf über 300 kuratierte Modelle über alle Modalitäten hinweg.

Schauen Sie sich die neue Coding-Plan-Aktion von Atlas Cloud für noch kostengünstigeren API-Zugriff an: https://www.atlascloud.ai/console/coding-plan

Beispiele:```bash

Using Atlas Cloud with the default DeepSeek V4 Flash model

export GOSEC_AI_API_KEY="your_key" export GOSEC_AI_PROVIDER="atlas" gosec ./...

Using Atlas Cloud with an explicit hosted model

GOSEC_AI_API_KEY="your_key"
gosec -ai-api-provider="atlas:qwen/qwen3-coder-next" ./...

Using Gemini

gosec -ai-api-provider="gemini-3-pro-preview"
-ai-api-key="your_key" ./...

Using Claude

gosec -ai-api-provider="claude-sonnet-4-6"
-ai-api-key="your_key" ./...

Using OpenAI

gosec -ai-api-provider="gpt-5.4"
-ai-api-key="your_key" ./...

Using Azure OpenAI

gosec -ai-api-provider="gpt-5.4"
-ai-api-key="your_azure_key"
-ai-base-url="https://your-resource.openai.azure.com/openai/deployments/your-deployment"
./...

Using local Ollama with custom model

gosec -ai-api-provider="llama3.2"
-ai-base-url="http://localhost:11434/v1"
./...

Using self-signed certificate API

gosec -ai-api-provider="custom-model"
-ai-api-key="your_key"
-ai-base-url="https://internal-api.company.com/v1"
-ai-skip-ssl
./...

### Annotieren von Code

Wie bei allen automatischen Erkennungstools gibt es auch hier
Fehlalarme. Wenn gosec einen Fehler meldet, der
manuell als sicher bestätigt wurde, kann der
Code mit einem Kommentar annotiert werden, der mit `#nosec` beginnt.

Der `#nosec`-Kommentar sollte das Format
`#nosec [RegelListe] [-- Begründung]` haben.

Der `#nosec`-Kommentar muss in der Zeile platziert werden, in der die
Warnung gemeldet wird.```go
func main() {
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true, // #nosec G402
		},
	}

	client := &http.Client{Transport: tr}
	_, err := client.Get("https://go.dev/")
	if err != nil {
		fmt.Println(err)
	}
}

Wenn ein spezifischer Fehlalarm identifiziert und als sicher bestätigt wurde, möchten Sie möglicherweise nur diese einzelne Regel (oder eine bestimmte Gruppe von Regeln) innerhalb eines Codeabschnitts unterdrücken, während Sie weiterhin nach anderen Problemen suchen. Dazu können Sie die zu unterdrückenden Regeln in der #nosec-Annotation auflisten, z.B.: /* #nosec G401 */ oder //#nosec G201 G202 G203

Sie könnten die Beschreibung oder den Begründungstext für die Annotation einfügen. Die Begründung sollte nach den zu unterdrückenden Regeln stehen und mit zwei oder mehr Bindestrichen beginnen, z.B.: //#nosec G101 G102 -- This is a false positive

Alternativ unterstützt gosec auch die Direktive //gosec:disable, die ähnlich wie #nosec funktioniert:```go //gosec:disable G101 -- This is a false positive

In manchen Fällen möchten Sie möglicherweise auch Stellen überprüfen, an denen `#nosec`- oder `//gosec:disable`-Anmerkungen verwendet wurden. Um den Scanner auszuführen und alle `#nosec`-Anmerkungen zu ignorieren, können Sie Folgendes tun:```bash
gosec -nosec=true ./...

Regel-IDs und Begründungen erforderlich machen

Um zu verhindern, dass Annotationen versehentlich nicht verwandte Regeln unterdrücken oder ohne Erklärung hinzugefügt werden, akzeptiert gosec zwei opt-in-Flags. Beide standardmäßig auf false, sodass bestehende Codebasen unverändert funktionieren.

• -nosec-require-rules lehnt nackte #nosec / //gosec:disable-Direktiven ab, die keine Regel-ID auflisten.
• -nosec-require-justification lehnt Direktiven ab, die nach der Regelliste keine -- justification enthalten.

Wenn aktiviert, unterdrückt eine Direktive, die die Prüfung nicht besteht, keinen Fund mehr und wird als Fehler in der Ausgabe gemeldet, zusammen mit allen zugrunde liegenden Problemen in der Zeile.```bash gosec -nosec-require-rules -nosec-require-justification ./...

Die gleichen Optionen können über den globalen Konfigurationsblock festgelegt werden:```json
{
    "global": {
        "nosec-require-rules": "enabled",
        "nosec-require-justification": "enabled"
    }
}

Unterdrückungen verfolgen

Wie oben beschrieben, können wir Verstöße extern (mit -include/-exclude) oder inline (mit #nosec-Annotationen) unterdrücken. Unterdrückungsmetadaten können zur Überprüfung ausgegeben werden. Aktivieren Sie die Verfolgung von Unterdrückungen mit -track-suppressions:```bash gosec -track-suppressions -exclude=G101
-fmt=sarif -out=results.sarif ./...

- Bei externen Suppressionen zeichnet gosec Suppressionsinformationen auf,
  wobei `kind` auf `external` und `justification` auf
  `Globally suppressed.` gesetzt ist.
- Bei Inline-Suppressionen zeichnet gosec Suppressionsinformationen auf,
  wobei `kind` auf `inSource` und `justification` auf den Text
  nach zwei oder mehr Bindestrichen im Kommentar gesetzt ist.

**Hinweis:** Nur die Formate SARIF und JSON unterstützen die Nachverfolgung
von Suppressionen.

### Build-Tags

gosec kann Ihre
[Go-Build-Tags](https://pkg.go.dev/go/build/) an den Analyzer übergeben.
Sie können als kommagetrennte Liste wie folgt angegeben werden:```bash
gosec -tags debug,ignore ./...

Ausgabeformate

gosec unterstützt text, json, yaml, csv, junit-xml, html, sonarqube, golint und sarif. Standardmäßig werden die Ergebnisse an die Standardausgabe (stdout) gemeldet, können aber auch in eine Ausgabedatei geschrieben werden. Das Ausgabeformat wird über das Flag -fmt gesteuert, und die Ausgabedatei über das Flag -out wie folgt:```bash

Write output in json format to results.json

$ gosec -fmt=json -out=results.json *.go

Use `-stdout` to print results while also writing `-out`.
Use `-verbose` to override stdout format while preserving the
file format.```bash
# Write output in json format to results.json as well as stdout
$ gosec -fmt=json -out=results.json -stdout *.go

# Overrides the output format to 'text' when stdout the results,
# while writing it to results.json
$ gosec -fmt=json -out=results.json -stdout -verbose=text *.go

Hinweis: gosec erzeugt das generic issue import format für SonarQube, und ein Bericht muss in SonarQube importiert werden mittels sonar.externalIssuesReportPaths=path/to/gosec-report.json.

Häufige Verwendungsmuster```bash

Fail only on medium+ severity findings

gosec -severity medium ./...

Fail only on medium+ confidence findings

gosec -confidence medium ./...

Exclude specific rules for specific paths

gosec --exclude-rules="cmd/.:G204,G304;scripts/.:*" ./...

Exclude generated files in scan

gosec -exclude-generated ./...

Include test files in scan

gosec -tests ./...

## Entwicklung

Die Entwicklungsdokumentation wurde verschoben nach
[DEVELOPMENT.md](https://github.com/securego/gosec/blob/HEAD/DEVELOPMENT.md).

## Wer verwendet gosec?

Dies ist eine [Liste](https://github.com/securego/gosec/blob/HEAD/USERS.md) mit einigen der gosec-Benutzer.

## Sponsoren

Unterstützen Sie dieses Projekt, indem Sie Sponsor werden. Ihr Logo wird
hier mit einem Link zu Ihrer Website erscheinen

<a href="https://github.com/mercedes-benz" target="_blank"><img src="https://assets.kitploit.com/production/public/readmes/2947/08b6f9da5faff0e986172b0c77fed0865a2cb26e6f8c58a8ae588c74bcf16f5f.png"></a>