gosec - Go Security Checker

Ispeziona il codice sorgente alla ricerca di problemi di sicurezza analizzando l'AST di Go e la rappresentazione del codice SSA.

Collegamenti rapidi

• GitHub Action
• Installazione locale
• Avvio rapido
• Pattern di utilizzo comuni
• Selezione delle regole
• Formati di output

Caratteristiche

• Regole basate su pattern per individuare problemi di sicurezza comuni nel codice Go
• Analizzatori basati su SSA per conversioni di tipo, limiti di slice e problemi crittografici
• Analisi del flusso dei dati per tracciare il flusso dei dati dall'input utente verso funzioni pericolose (SQL injection, command injection, path traversal, SSRF, XSS, log injection, SMTP injection, SSTI, deserializzazione non sicura, open redirect)

Licenza

Concesso in licenza secondo i termini dell'Apache License, Versione 2.0 (la "Licenza"). Non è consentito utilizzare questo file se non in conformità con la Licenza. È possibile ottenere una copia della Licenza qui.

Stato del progetto

Installazione

GitHub Action

Puoi eseguire gosec come azione GitHub come segue:

Usa il tag versionato con @master che è fissato all'ultima release stabile. Questo fornirà un comportamento stabile.```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: ./...

#### Scansione di progetti con moduli privati

Se il tuo progetto importa moduli Go privati, devi
configurare l'autenticazione in modo che `gosec` possa recuperare le
dipendenze. Imposta le seguenti variabili d'ambiente nel
tuo workflow:

- `GOPRIVATE`: un elenco separato da virgole di prefissi di percorso dei moduli
  che dovrebbero essere considerati privati
  (ad es., `github.com/your-org/*`).
- `GITHUB_AUTHENTICATION_TOKEN`: un token GitHub con accesso in lettura
  ai tuoi repository privati.```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: ./...

Integrazione con la scansione del codice

Puoi integrare strumenti di analisi del codice di terze parti con la scansione del codice di GitHub caricando i dati come file SARIF.

Il flusso di lavoro mostra un esempio di esecuzione di gosec come passaggio in un flusso di lavoro di GitHub Action che produce il file results.sarif. Il flusso di lavoro quindi carica il file results.sarif su GitHub utilizzando l'azione upload-sarif.```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

Il pacchetto `goanalysis` fornisce un
[`golang.org/x/tools/go/analysis.Analyzer`](https://pkg.go.dev/golang.org/x/tools/go/analysis)
per l'integrazione con strumenti che supportano l'interfaccia standard di analisi di Go, come il framework
[nogo](https://github.com/bazelbuild/rules_go/blob/master/go/nogo.rst)
di Bazel:```starlark
nogo(
    name = "nogo",
    deps = [
        "@com_github_securego_gosec_v2//goanalysis",
        # add more analyzers as needed
    ],
    visibility = ["//visibility:public"],
)

Installazione locale

gosec richiede Go 1.25 o superiore.```bash go install github.com/securego/gosec/v2/cmd/gosec@latest

## Avvio rapido```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 ./...

Codici di uscita

• 0: scansione completata senza risultati/errori non soppressi
• 1: almeno un risultato non soppresso o errore di elaborazione
• Usa -no-fail per restituire sempre 0

Utilizzo

Gosec può essere configurato per eseguire solo un sottoinsieme di regole, escludere determinati percorsi di file e produrre report in formati diversi. Per impostazione predefinita, tutte le regole vengono eseguite sui file di input forniti. Per eseguire una scansione ricorsiva dalla directory corrente, puoi fornire ./... come argomento di input.

Regole disponibili

gosec include regole in queste categorie:

• G1xx: problemi generali di codifica sicura (ad esempio, credenziali hardcoded, utilizzo non sicuro, hardening HTTP, sicurezza dei cookie)
• G2xx: rischi di injection nella costruzione di query/template/comandi
• G3xx: rischi di gestione di file e percorsi (permessi, traversal, file temporanei, estrazione di archivi)
• G4xx: debolezze crittografiche e TLS
• G5xx: import bloccati
• G6xx: controlli di correttezza/sicurezza specifici di Go (ad esempio, aliasing di range e limiti di slice)
• G7xx: regole di analisi del taint (SQL injection, command injection, path traversal, SSRF, XSS, log, SMTP injection, SSTI, deserializzazione non sicura e open redirect)

Per l'elenco completo, le descrizioni delle regole e la configurazione per regola, consulta RULES.md.

Regole ritirate

• G105: Verifica dell'uso di math/big.Int.Exp - CVE risolta
• G307: Deferire un metodo che restituisce un errore - causa più inconvenienti che risolvere un problema di sicurezza, nonostante i dettagli di questo post del blog

Selezione delle regole

Per impostazione predefinita, gosec esegue tutte le regole sui percorsi dei file forniti. È comunque possibile selezionare un sottoinsieme di regole da eseguire tramite il flag -include=, o specificare un insieme di regole da escludere esplicitamente usando il flag -exclude=.```bash

Run a specific set of rules

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

Run everything except for rule G303

$ gosec -exclude=G303 ./...

### CWE Mapping

Every issue detected by `gosec` is mapped to a
[CWE (Common Weakness Enumeration)](http://cwe.mitre.org/data/index.html)
which describes in more generic terms the vulnerability. The
exact mapping can be found
[here](https://github.com/securego/gosec/blob/master/issue/issue.go#L50).

### Configurazione

Un certo numero di impostazioni globali possono essere fornite in un file di configurazione come segue:```JSON
{
    "global": {
        "nosec": "enabled",
        "audit": "enabled"
    }
}

• nosec: questa impostazione sovrascriverà tutte le direttive #nosec definite in tutto il codice
• audit: esegue in modalità audit che abilita controlli aggiuntivi che per l'analisi normale del codice potrebbero essere troppo invadenti```bash

Run with a global configuration file

$ gosec -conf config.json .

### Esclusioni delle regole basate sul percorso

I repository di grandi dimensioni con più componenti possono aver bisogno di regole di sicurezza diverse per percorsi diversi. Utilizza `exclude-rules` per sopprimere regole specifiche per percorsi specifici.

**File di configurazione:**```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" ./...

| Field | Type | Description |
|-------|------|-------------|
| `path` | string (regex) | Regex confrontato con i percorsi dei file |
| `rules` | []string | ID delle regole da escludere. `*` per tutte |

#### Configurazione delle Regole

Alcune regole accettano anche flag di configurazione; questi flag sono documentati in
[RULES.md](https://github.com/securego/gosec/blob/master/RULES.md).

#### Versione Go

Alcune regole richiedono una versione specifica di Go che viene recuperata
dal file del modulo Go presente nel progetto. Se questa versione
non viene trovata, verrà utilizzata la versione runtime di Go.

La versione del modulo Go viene analizzata usando il comando `go list`
che in alcuni casi potrebbe portare a un degrado delle prestazioni. In
questa situazione, la versione del modulo Go può essere facilmente fornita
impostando la variabile d'ambiente
`GOSECGOVERSION=go1.21.1`.

### Dipendenze

gosec carica i pacchetti usando i moduli Go. Nella maggior parte dei progetti,
le dipendenze vengono risolte automaticamente durante la scansione.

Se le dipendenze mancano, esegui:```bash
go mod tidy
go mod download

Esclusione di file e cartelle di test

gosec ignorerà i file di test in tutti i pacchetti e tutte le dipendenze nella directory vendor.

La scansione dei file di test può essere attivata con il seguente flag:```bash gosec -tests ./...

Inoltre, è possibile escludere ulteriori cartelle come segue:```bash
 gosec -exclude-dir=rules -exclude-dir=cmd ./...

Esclusione dei file generati

gosec può ignorare i file go generati con il commento di codice generato predefinito.``` // Code generated by some generator DO NOT EDIT.

e 2017 e 2016, fino ad oggi. L'aggiornamento sulla lista CWE per il nuovo anno è in corso e speriamo di fornire una seria caccia alle vulnerabilità quando i nuovi rilasci CWE saranno pronti.

**Si prega di notare che il database delle vulnerabilità ha un limite di applicazione di 5 anni. Se vedi qualcosa in una delle nostre fonti o altrove, contattaci e lo aggiungeremo.**

**Nel frattempo, diamo il benvenuto a chiunque voglia contribuire al progetto e aiutarci a mantenere e aggiornare il database.**

Inoltre, per lo script `list_cves.py`, c'è un'altra possibile modalità usando `--verbose` o `-v`:

````bash
gosec -exclude-generated ./...

Correzione automatica delle vulnerabilità

gosec può suggerire correzioni basate su raccomandazioni AI. Chiama un'API AI per ricevere un suggerimento per una scoperta di sicurezza.

Puoi abilitare questa funzionalità fornendo i seguenti argomenti da riga di comando:

• ai-api-provider: il nome del provider dell'API AI. Provider supportati:
  • Atlas Cloud: atlas (modello predefinito deepseek-ai/deepseek-v4-flash), atlas-deepseek-v4-flash, atlas-qwen3-coder-next, atlas-kimi-k2.6, o atlas:<model-id> per qualsiasi modello chat ospitato da Atlas Cloud. Atlas Cloud è un provider compatibile con OpenAI disponibile su atlascloud.ai
  • Gemini: gemini-3-pro-preview (predefinito), gemini-2.5-pro, gemini-2.5-flash, gemini-2.5-flash-lite
  • Claude: claude-sonnet-4-6 (predefinito), , , , ,

🎁 Atlas Cloud è una piattaforma di inferenza AI multimodale che offre agli sviluppatori una singola API AI per accedere a generazione video, generazione di immagini e API LLM. Invece di gestire molteplici integrazioni con vendor, ti connetti una volta e ottieni accesso unificato a oltre 300 modelli curati in tutte le modalità.

Dai un'occhiata alla nuova promozione del piano di coding di Atlas Cloud per un accesso API più economico: https://www.atlascloud.ai/console/coding-plan

Esempi:```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
./...

### Annotazione del codice

Come per tutti gli strumenti di rilevamento automatico, ci saranno casi di
falsi positivi. Nei casi in cui gosec segnala un errore che
è stato verificato manualmente come sicuro, è possibile
annotare il codice con un commento che inizia con `#nosec`.

Il commento `#nosec` deve avere il formato
`#nosec [RuleList] [-- Justification]`.

Il commento `#nosec` deve essere posizionato sulla riga in cui
viene segnalato l'avviso.```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)
	}
}

Quando un falso positivo specifico è stato identificato e verificato come sicuro, potresti voler sopprimere solo quella singola regola (o un insieme specifico di regole) all'interno di una sezione di codice, continuando a scansionare per altri problemi. Per farlo, puoi elencare la o le regole da sopprimere all'interno dell'annotazione #nosec, ad esempio: /* #nosec G401 */ oppure //#nosec G201 G202 G203

Puoi inserire il testo descrittivo o di giustificazione per l'annotazione. La giustificazione deve essere dopo la o le regole da sopprimere e iniziare con due o più trattini, ad esempio: //#nosec G101 G102 -- Questo è un falso positivo

In alternativa, gosec supporta anche la direttiva //gosec:disable, che funziona in modo simile a #nosec:```go //gosec:disable G101 -- This is a false positive

In alcuni casi potresti anche voler rivedere i punti in cui sono state utilizzate le annotazioni `#nosec` o `//gosec:disable`. Per eseguire lo scanner ignorando qualsiasi annotazione `#nosec`, puoi fare quanto segue:```bash
gosec -nosec=true ./...

Richiesta di ID regola e giustificazioni

Per evitare che le annotazioni sopprimano involontariamente regole non correlate, o vengano aggiunte senza spiegazione, gosec accetta due flag opzionali. Entrambi predefiniti a false, quindi i codebase esistenti continuano a funzionare invariati.

• -nosec-require-rules rifiuta direttive #nosec / //gosec:disable nude che non elencano alcun ID regola.
• -nosec-require-justification rifiuta direttive che non portano un -- justification dopo l'elenco delle regole.

Quando abilitata, una direttiva che fallisce il controllo non sopprime più alcun riscontro e viene segnalata come un errore nell'output, insieme a qualsiasi problema sottostante sulla riga.```bash gosec -nosec-require-rules -nosec-require-justification ./...

Le stesse opzioni possono essere impostate tramite il blocco di configurazione globale:```json
{
    "global": {
        "nosec-require-rules": "enabled",
        "nosec-require-justification": "enabled"
    }
}

Tracciamento delle soppressioni

Come descritto sopra, possiamo sopprimere le violazioni esternamente (usando -include/-exclude) o inline (usando le annotazioni #nosec). I metadati di soppressione possono essere emessi per l'audit.

Abilita il tracciamento delle soppressioni con -track-suppressions:```bash gosec -track-suppressions -exclude=G101
-fmt=sarif -out=results.sarif ./...

- Per le soppressioni esterne, gosec registra le informazioni di soppressione dove `kind` è `external` e `justification` è `Soppresso globalmente.`
- Per le soppressioni inline, gosec registra le informazioni di soppressione dove `kind` è `inSource` e `justification` è il testo dopo due o più trattini nel commento.

**Nota:** Solo i formati SARIF e JSON supportano il tracciamento delle soppressioni.

### Tag di build

gosec è in grado di passare i tuoi [tag di build Go](https://pkg.go.dev/go/build/) all'analizzatore. Possono essere forniti come elenco separato da virgole come segue:```bash
gosec -tags debug,ignore ./...

Output formats

gosec supporta i formati text, json, yaml, csv, junit-xml, html, sonarqube, golint e sarif. Di default, i risultati vengono riportati su stdout, ma possono anche essere scritti su un file di output. Il formato di output è controllato dal flag -fmt e il file di output è controllato dal flag -out come segue:```bash

Write output in json format to results.json

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

Use `-stdout` per stampare i risultati mentre si scrive anche `-out`.
Use `-verbose` per sovrascrivere il formato di stdout preservando il
formato del file.```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

Nota: gosec genera il formato di importazione dei problemi generici per SonarQube, e un report deve essere importato in SonarQube utilizzando sonar.externalIssuesReportPaths=path/to/gosec-report.json.

Pattern di utilizzo comuni```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 ./...

## Sviluppo

La documentazione di sviluppo è stata spostata su
[DEVELOPMENT.md](https://github.com/securego/gosec/blob/HEAD/DEVELOPMENT.md).

## Chi usa gosec?

Questa è una [lista](https://github.com/securego/gosec/blob/HEAD/USERS.md) di alcuni utenti di gosec.

## Sponsor

Supporta questo progetto diventando uno sponsor. Il tuo logo apparirà qui con un link al tuo sito web

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