securego/gosecControllo di sicurezza per Go
# 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.
<img src="https://assets.kitploit.com/production/public/readmes/2947/83d294db3a312bcea542b6eb8261128e6f09b50a95271788fe301e164b1655b1.png" width="320">
## Link rapidi
- [GitHub Action](#github-action)
- [Installazione locale](#local-installation)
- [Avvio rapido](#quick-start)
- [Modelli di utilizzo comuni](#common-usage-patterns)
- [Selezione delle regole](#selecting-rules)
- [Formati di output](#output-formats)
## Funzionalità
- **Regole basate su pattern** per rilevare problemi di sicurezza comuni
nel codice Go
- **Analizzatori basati su SSA** per conversioni di tipo, limiti delle slice
e problemi crittografici
- **Analisi di taint** per tracciare il flusso di 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 la Apache License, Version 2.0 (la "Licenza").
Non è possibile utilizzare questo file se non in conformità con la Licenza.
È possibile ottenere una copia della Licenza
[qui](http://www.apache.org/licenses/LICENSE-2.0).
## Stato del progetto
[](https://bestpractices.coreinfrastructure.org/projects/3218)
[](https://github.com/securego/gosec/actions?query=workflows%3ACI)
[](https://codecov.io/gh/securego/gosec)
[](https://goreportcard.com/report/github.com/securego/gosec)
[](https://pkg.go.dev/github.com/securego/gosec/v2)
[](https://securego.io/)
[](https://github.com/securego/gosec/releases)
[](https://github.com/orgs/securego/packages/container/package/gosec)
[](http://securego.slack.com)
[](https://github.com/nikolaydubina/go-recipes)
## Installazione
### GitHub Action
È possibile eseguire `gosec` come GitHub action nel modo seguente:
Utilizzare il tag versionato con `@master`, che è fissato alla
release stabile più recente. Questo garantirà 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 affinché `gosec` possa recuperare le
dipendenze. Imposta le seguenti variabili d'ambiente nel
tuo workflow:
- `GOPRIVATE`: un elenco separato da virgole di prefissi di percorsi di moduli
che devono 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](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/integrating-with-code-scanning)
con la scansione del codice di GitHub caricando i dati come file SARIF.
Il workflow mostra un esempio di esecuzione di `gosec` come step
in un workflow di GitHub action che produce il file `results.sarif`.
Il workflow carica quindi il file `results.sarif` su
GitHub utilizzando l'action `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
```
### Analisi Go
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 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 versione successiva.
```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
- Usare `-no-fail` per restituire sempre `0`
## Utilizzo
Gosec può essere configurato per eseguire solo un sottoinsieme di regole, per
escludere determinati percorsi di file e per 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
è possibile fornire `./...` come argomento di input.
### Regole disponibili
gosec include regole appartenenti a queste categorie:
- `G1xx`: problemi generali di codifica sicura (ad esempio credenziali
hardcoded, utilizzo non sicuro, rafforzamento HTTP, sicurezza dei cookie)
- `G2xx`: rischi di injection nella costruzione di query/template/comandi
- `G3xx`: rischi nella gestione di file e percorsi (permessi, traversal,
file temporanei, estrazione di archivi)
- `G4xx`: debolezze crittografiche e TLS
- `G5xx`: import in blocklist
- `G6xx`: controlli di correttezza/sicurezza specifici di Go (ad esempio
aliasing nelle range e limiti delle slice)
- `G7xx`: regole di taint analysis (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 singola regola, vedere [RULES.md](https://github.com/securego/gosec/blob/master/RULES.md).
### Regole ritirate
- G105: Audit dell'uso di math/big.Int.Exp -
[La CVE è stata corretta](https://github.com/golang/go/issues/15184)
- G307: Deferring di un metodo che restituisce un errore - causa
più inconvenienti che risolvere un problema di sicurezza, nonostante
i dettagli di questo
[post del blog](https://www.joeshaw.org/dont-defer-close-on-writable-files/)
### Selezione delle regole
Per impostazione predefinita, gosec eseguirà tutte le regole sui percorsi di file
forniti. È tuttavia possibile selezionare un sottoinsieme di regole da
eseguire tramite il flag `-include=`, oppure 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 ./...
```
### Mappatura CWE
Ogni problema rilevato da `gosec` è mappato a una
[CWE (Common Weakness Enumeration)](http://cwe.mitre.org/data/index.html)
che descrive in termini più generici la vulnerabilità. La
mappatura esatta è disponibile
[qui](https://github.com/securego/gosec/blob/master/issue/issue.go#L50).
### Configurazione
È possibile fornire una serie di impostazioni globali 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 invasivi
```bash
# Run with a global configuration file
$ gosec -conf config.json .
```
### Esclusioni di regole basate sul percorso
Repository di grandi dimensioni con più componenti potrebbero richiedere 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": ["*"]
}
]
}
```
**Flag CLI:**
```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" ./...
```
| Campo | Tipo | Descrizione |
|-------|------|-------------|
| `path` | string (regex) | Regex confrontata 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 di Go
Alcune regole richiedono una versione specifica di Go, recuperata
dal file del modulo Go presente nel progetto. Se questa versione
non può essere trovata, si ricorrerà alla versione del runtime Go.
La versione del modulo Go viene analizzata tramite il comando `go list`
che in alcuni casi potrebbe causare 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 utilizzando i moduli Go. Nella maggior parte dei progetti,
le dipendenze vengono risolte automaticamente durante la scansione.
Se mancano delle dipendenze, eseguire:
```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 qualsiasi
dipendenza nella tua directory vendor.
La scansione dei file di test può essere abilitata con il seguente
flag:
```bash
gosec -tests ./...
```
Anche cartelle aggiuntive possono essere escluse come segue:
```bash
gosec -exclude-dir=rules -exclude-dir=cmd ./...
```
### Esclusione dei file generati
gosec può ignorare i file Go generati con il commento predefinito
di codice generato.
```
// Code generated by some generator DO NOT EDIT.
```
```bash
gosec -exclude-generated ./...
```
### Correzione automatica delle vulnerabilità
gosec può suggerire correzioni basate sulle raccomandazioni dell'IA. Chiamerà un'API IA per ricevere un suggerimento per un risultato di sicurezza.
Puoi abilitare questa funzionalità fornendo i seguenti argomenti da riga di comando:
- `ai-api-provider`: il nome del provider dell'API IA.
Provider supportati:
- **Atlas Cloud**: `atlas` (modello predefinito
`deepseek-ai/deepseek-v4-flash`),
`atlas-deepseek-v4-flash`,
`atlas-qwen3-coder-next`, `atlas-kimi-k2.6`, oppure
`atlas:<model-id>` per qualsiasi modello chat ospitato su Atlas Cloud.
Atlas Cloud è un provider compatibile con OpenAI disponibile su
[atlascloud.ai](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=gosec)
- **Gemini**: `gemini-3.1-pro-preview` (predefinito),
`gemini-2.5-pro`, `gemini-2.5-flash`,
`gemini-2.5-flash-lite`
- **Claude**: `claude-sonnet-4-6` (predefinito),
`claude-opus-4-7`, `claude-opus-4-6`,
`claude-sonnet-4-5`, `claude-opus-4-5`,
`claude-haiku-4-5`
- **OpenAI**: `gpt-5.4` (predefinito), `gpt-5.4-mini`,
`gpt-5.4-nano`
- **OpenAI-compatibile personalizzato**: qualsiasi nome di modello personalizzato
(richiede `ai-base-url`)
- `ai-api-key` oppure imposta la variabile d'ambiente
`GOSEC_AI_API_KEY`: la chiave per accedere all'API IA
- Per Gemini, puoi creare una chiave API seguendo
[queste istruzioni](https://ai.google.dev/gemini-api/docs/api-key)
- Per Claude, ottieni la tua chiave API dalla
[Anthropic Console](https://console.anthropic.com/)
- Per OpenAI, ottieni la tua chiave API dalla
[OpenAI Platform](https://platform.openai.com/api-keys)
- `ai-base-url`: (opzionale) URL di base personalizzato per
API compatibili con OpenAI (ad es. Azure OpenAI, LocalAI,
Ollama)
- Atlas Cloud utilizza `https://api.atlascloud.ai/v1` per impostazione predefinita,
quindi `ai-base-url` è opzionale per il provider `atlas`
integrato
- `GOSEC_AI_PROVIDER`: (opzionale) variabile d'ambiente
alternativa a `ai-api-provider`
- `GOSEC_AI_BASE_URL`: (opzionale) variabile d'ambiente
alternativa a `ai-base-url`
- `ai-skip-ssl`: (opzionale) salta la verifica del certificato SSL
per l'API IA (utile per certificati autofirmati)
> 🎁 **[Atlas Cloud](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=gosec)** è una piattaforma di inferenza IA full-modal che offre agli sviluppatori un'unica API IA per accedere alle API di generazione video, generazione immagini e LLM. Invece di gestire più integrazioni con fornitori, ti connetti una sola volta e ottieni un accesso unificato a oltre 300 modelli curati in tutte le modalità.
>
> Scopri la nuova promozione del piano di coding di Atlas Cloud per un accesso API più conveniente: [https://www.atlascloud.ai/console/coding-plan](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.1-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 \
./...
```
### Annotare il codice
Come con tutti gli strumenti di rilevamento automatizzato, 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` dovrebbe 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 è stato identificato e verificato come sicuro uno specifico falso positivo, potresti voler sopprimere solo quella singola regola (o uno specifico insieme di regole) all'interno di una sezione di codice, continuando a scansionare alla ricerca di altri problemi. Per fare ciò, puoi elencare la/le regola/e da sopprimere all'interno dell'annotazione `#nosec`, ad es: `/* #nosec G401 */` o `//#nosec G201 G202 G203`
Potresti inserire il testo descrittivo o di giustificazione per l'annotazione. La giustificazione dovrebbe essere dopo la/le regola/e da sopprimere e iniziare con due o più trattini, ad es: `//#nosec G101 G102 -- This is a false positive`
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 rivisitare i punti in cui sono state utilizzate annotazioni `#nosec` o `//gosec:disable`. Per eseguire lo scanner e ignorare qualsiasi annotazione `#nosec` puoi procedere come segue:
```bash
gosec -nosec=true ./...
```
#### Richiedere ID delle regole e giustificazioni
Per evitare che le annotazioni sopprimano inavvertitamente regole non correlate, o che vengano aggiunte senza spiegazione, gosec accetta due flag opt-in. Entrambi hanno come valore predefinito `false`, quindi i codebase esistenti continuano a funzionare senza modifiche.
- `-nosec-require-rules` rifiuta le direttive nude `#nosec` / `//gosec:disable` che non elencano alcun ID di regola.
- `-nosec-require-justification` rifiuta le direttive che non riportano una `-- justification` dopo l'elenco delle regole.
Quando abilitata, una direttiva che non supera il controllo non sopprime più alcun finding e viene segnalata come 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"
}
}
```
### Monitoraggio delle soppressioni
Come descritto sopra, è possibile sopprimere le violazioni esternamente
(usando `-include`/`-exclude`) o inline (usando le annotazioni `#nosec`).
I metadati delle soppressioni possono essere emessi per finalità di audit.
Abilita il monitoraggio 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` è
`Globally suppressed.`.
- 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.
### Build tags
gosec è in grado di passare i tuoi
[Go build tags](https://pkg.go.dev/go/build/) all'analyzer.
Possono essere forniti come elenco separato da virgole come segue:
```bash
gosec -tags debug,ignore ./...
```
### Formati di output
gosec supporta `text`, `json`, `yaml`, `csv`, `junit-xml`,
`html`, `sonarqube`, `golint` e `sarif`. Per impostazione predefinita,
i risultati vengono riportati su stdout, ma possono anche essere scritti
in 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
```
Usa `-stdout` per stampare i risultati mentre scrivi anche `-out`.
Usa `-verbose` per sovrascrivere il formato 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 generico dei problemi](https://docs.sonarqube.org/latest/analysis/generic-issue/)
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 per lo sviluppo è stata spostata in
[DEVELOPMENT.md](https://github.com/securego/gosec/blob/master/DEVELOPMENT.md).
## Chi utilizza gosec?
Questa è una [lista](https://github.com/securego/gosec/blob/master/USERS.md) con alcuni degli utenti di gosec.
## Sponsor
Sostieni 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>