securego/gosecVérificateur de sécurité Go
# gosec - Vérificateur de sécurité pour Go
Inspecte le code source à la recherche de problèmes de sécurité en analysant l'AST Go
et la représentation du code SSA.
<img src="https://assets.kitploit.com/production/public/readmes/2947/83d294db3a312bcea542b6eb8261128e6f09b50a95271788fe301e164b1655b1.png" width="320">
## Liens rapides
- [GitHub Action](#github-action)
- [Installation locale](#local-installation)
- [Démarrage rapide](#quick-start)
- [Modèles d'utilisation courants](#common-usage-patterns)
- [Sélection des règles](#selecting-rules)
- [Formats de sortie](#output-formats)
## Fonctionnalités
- **Règles basées sur des motifs** pour détecter les problèmes de sécurité courants
dans le code Go
- **Analyseurs basés sur la SSA** pour les conversions de types, les limites de tranches
et les problèmes cryptographiques
- **Analyse de teinte (taint analysis)** pour suivre le flux de données depuis les entrées utilisateur jusqu'aux
fonctions dangereuses (injection SQL, injection de commandes, traversée de chemin,
SSRF, XSS, injection de logs, injection SMTP, SSTI,
désérialisation non sécurisée, redirection ouverte)
## Licence
Sous licence Apache License, Version 2.0 (la « Licence »).
Vous ne pouvez pas utiliser ce fichier sauf en conformité avec la Licence.
Vous pouvez obtenir une copie de la Licence
[ici](http://www.apache.org/licenses/LICENSE-2.0).
## État du projet
[](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)
## Installation
### GitHub Action
Vous pouvez exécuter `gosec` en tant que GitHub action comme suit :
Utilisez le tag versionné avec `@master` qui est épinglé sur la
dernière version stable. Cela garantira un comportement stable.
```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: ./...
```
#### Analyser des projets avec des modules privés
Si votre projet importe des modules Go privés, vous devez
configurer l'authentification afin que `gosec` puisse récupérer les
dépendances. Définissez les variables d'environnement suivantes dans
votre workflow :
- `GOPRIVATE` : une liste séparée par des virgules de préfixes de chemins de modules
qui doivent être considérés comme privés
(par exemple, `github.com/your-org/*`).
- `GITHUB_AUTHENTICATION_TOKEN` : un jeton GitHub disposant d'un accès en lecture
à vos dépôts privés.
```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: ./...
```
### Intégration avec l'analyse de code
Vous pouvez [intégrer des outils d'analyse de code tiers](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/integrating-with-code-scanning)
à l'analyse de code GitHub en téléversant des données sous forme de fichiers SARIF.
Le workflow montre un exemple d'exécution de `gosec` en tant qu'étape
dans un workflow GitHub action qui produit le fichier `results.sarif`.
Le workflow téléverse ensuite le fichier `results.sarif` vers
GitHub à l'aide de 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
```
### Analyse Go
Le paquet `goanalysis` fournit un
[`golang.org/x/tools/go/analysis.Analyzer`](https://pkg.go.dev/golang.org/x/tools/go/analysis)
pour l'intégration avec les outils qui prennent en charge l'interface
d'analyse standard de Go, tels que le framework
[nogo](https://github.com/bazelbuild/rules_go/blob/master/go/nogo.rst)
de Bazel :
```starlark
nogo(
name = "nogo",
deps = [
"@com_github_securego_gosec_v2//goanalysis",
# add more analyzers as needed
],
visibility = ["//visibility:public"],
)
```
### Installation locale
gosec nécessite Go 1.25 ou une version plus récente.
```bash
go install github.com/securego/gosec/v2/cmd/gosec@latest
```
## Démarrage rapide
```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 ./...
```
### Codes de sortie
- `0` : analyse terminée sans résultats ni erreurs non supprimés
- `1` : au moins un résultat ou une erreur de traitement non supprimé
- Utilisez `-no-fail` pour toujours renvoyer `0`
## Utilisation
Gosec peut être configuré pour n'exécuter qu'un sous-ensemble de règles, pour
exclure certains chemins de fichiers et pour produire des rapports dans différents
formats. Par défaut, toutes les règles sont exécutées sur les fichiers
d'entrée fournis. Pour analyser récursivement depuis le répertoire courant, vous
pouvez fournir `./...` comme argument d'entrée.
### Règles disponibles
gosec inclut des règles réparties dans ces catégories :
- `G1xx` : problèmes généraux de codage sécurisé (par exemple identifiants
codés en dur, utilisation non sécurisée, durcissement HTTP, sécurité des cookies)
- `G2xx` : risques d'injection dans la construction de requêtes, de modèles ou de
commandes
- `G3xx` : risques de gestion des fichiers et des chemins (permissions, traversée
de répertoires, fichiers temporaires, extraction d'archives)
- `G4xx` : faiblesses cryptographiques et TLS
- `G5xx` : imports sur liste noire
- `G6xx` : vérifications de correction/sécurité spécifiques à Go (par exemple
l'aliasing de range et les bornes de slices)
- `G7xx` : règles d'analyse de teinte (injection SQL, injection de
commandes, traversée de chemins, SSRF, XSS, journalisation, injection SMTP,
SSTI, désérialisation non sécurisée et redirection ouverte)
Pour la liste complète, les descriptions des règles et la configuration
par règle, consultez [RULES.md](https://github.com/securego/gosec/blob/master/RULES.md).
### Règles retirées
- G105 : Audit de l'utilisation de math/big.Int.Exp -
[La CVE est corrigée](https://github.com/golang/go/issues/15184)
- G307 : Différer une méthode qui renvoie une erreur - cause
plus de désagréments que la correction d'un problème de sécurité, malgré les
détails de cet
[article de blog](https://www.joeshaw.org/dont-defer-close-on-writable-files/)
### Sélection des règles
Par défaut, gosec exécute toutes les règles sur les chemins de fichiers
fournis. Il est toutefois possible de sélectionner un sous-ensemble de règles à
exécuter via le drapeau `-include=`, ou de spécifier un ensemble de règles à
exclure explicitement à l'aide du drapeau `-exclude=`.
```bash
# Run a specific set of rules
$ gosec -include=G101,G203,G401 ./...
# Run everything except for rule G303
$ gosec -exclude=G303 ./...
```
### Mappage CWE
Chaque problème détecté par `gosec` est associé à une
[CWE (Common Weakness Enumeration)](http://cwe.mitre.org/data/index.html)
qui décrit la vulnérabilité en termes plus génériques. Le
mappage exact est disponible
[ici](https://github.com/securego/gosec/blob/master/issue/issue.go#L50).
### Configuration
Un certain nombre de paramètres globaux peuvent être fournis dans un fichier
de configuration comme suit :
```JSON
{
"global": {
"nosec": "enabled",
"audit": "enabled"
}
}
```
- `nosec` : ce paramètre écrasera toutes les directives `#nosec`
définies dans l'ensemble de la base de code
- `audit` : s'exécute en mode audit, ce qui active des vérifications supplémentaires
qui, pour une analyse de code normale, pourraient être trop intrusives
```bash
# Run with a global configuration file
$ gosec -conf config.json .
```
### Exclusions de règles basées sur les chemins
Les grands dépôts comportant plusieurs composants peuvent nécessiter des
règles de sécurité différentes selon les chemins. Utilisez `exclude-rules` pour
supprimer des règles spécifiques pour des chemins spécifiques.
**Fichier de configuration :**
```json
{
"exclude-rules": [
{
"path": "cmd/.*",
"rules": ["G204", "G304"]
},
{
"path": "scripts/.*",
"rules": ["*"]
}
]
}
```
**Option 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" ./...
```
| Champ | Type | Description |
|-------|------|-------------|
| `path` | string (regex) | Regex comparée aux chemins de fichiers |
| `rules` | []string | ID de règles à exclure. `*` pour toutes |
#### Configuration des règles
Certaines règles acceptent également des indicateurs de configuration ; ces indicateurs sont
documentés dans
[RULES.md](https://github.com/securego/gosec/blob/master/RULES.md).
#### Version de Go
Certaines règles nécessitent une version spécifique de Go, récupérée
à partir du fichier de module Go présent dans le projet. Si cette version
est introuvable, la version d'exécution de Go sera utilisée par défaut.
La version du module Go est analysée à l'aide de la commande `go list`
ce qui, dans certains cas, peut entraîner une dégradation des performances. Dans
cette situation, la version du module Go peut être facilement fournie en
définissant la variable d'environnement
`GOSECGOVERSION=go1.21.1`.
### Dépendances
gosec charge les paquets à l'aide des modules Go. Dans la plupart des projets,
les dépendances sont résolues automatiquement lors de l'analyse.
Si des dépendances sont manquantes, exécutez :
```bash
go mod tidy
go mod download
```
### Exclusion des fichiers et dossiers de test
gosec ignorera les fichiers de test dans tous les packages et toutes
les dépendances de votre répertoire vendor.
L'analyse des fichiers de test peut être activée avec le
flag suivant :
```bash
gosec -tests ./...
```
Des dossiers supplémentaires peuvent également être exclus comme suit :
```bash
gosec -exclude-dir=rules -exclude-dir=cmd ./...
```
### Exclusion des fichiers générés
gosec peut ignorer les fichiers Go générés grâce au commentaire de code généré par défaut.
```
// Code generated by some generator DO NOT EDIT.
```
```bash
gosec -exclude-generated ./...
```
### Correction automatique des vulnérabilités
gosec peut suggérer des correctifs basés sur une recommandation d'IA. Il
appelle une API d'IA pour recevoir une suggestion concernant une
vulnérabilité détectée.
Vous pouvez activer cette fonctionnalité en fournissant les arguments
de ligne de commande suivants :
- `ai-api-provider` : le nom du fournisseur d'API d'IA.
Fournisseurs pris en charge :
- **Atlas Cloud** : `atlas` (modèle par défaut
`deepseek-ai/deepseek-v4-flash`),
`atlas-deepseek-v4-flash`,
`atlas-qwen3-coder-next`, `atlas-kimi-k2.6`, ou
`atlas:<model-id>` pour tout modèle de chat hébergé par Atlas Cloud.
Atlas Cloud est un fournisseur compatible OpenAI disponible sur
[atlascloud.ai](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=gosec)
- **Gemini** : `gemini-3.1-pro-preview` (par défaut),
`gemini-2.5-pro`, `gemini-2.5-flash`,
`gemini-2.5-flash-lite`
- **Claude** : `claude-sonnet-4-6` (par défaut),
`claude-opus-4-7`, `claude-opus-4-6`,
`claude-sonnet-4-5`, `claude-opus-4-5`,
`claude-haiku-4-5`
- **OpenAI** : `gpt-5.4` (par défaut), `gpt-5.4-mini`,
`gpt-5.4-nano`
- **Compatible OpenAI personnalisé** : tout nom de modèle personnalisé
(nécessite `ai-base-url`)
- `ai-api-key` ou définissez la variable d'environnement
`GOSEC_AI_API_KEY` : la clé pour accéder à l'API d'IA
- Pour Gemini, vous pouvez créer une clé d'API en suivant
[ces instructions](https://ai.google.dev/gemini-api/docs/api-key)
- Pour Claude, obtenez votre clé d'API depuis
[Anthropic Console](https://console.anthropic.com/)
- Pour OpenAI, obtenez votre clé d'API depuis
[OpenAI Platform](https://platform.openai.com/api-keys)
- `ai-base-url` : (facultatif) URL de base personnalisée pour
les API compatibles OpenAI (par ex. Azure OpenAI, LocalAI,
Ollama)
- Atlas Cloud utilise `https://api.atlascloud.ai/v1` par défaut,
donc `ai-base-url` est facultatif pour le fournisseur `atlas`
intégré
- `GOSEC_AI_PROVIDER` : (facultatif) variable d'environnement
alternative à `ai-api-provider`
- `GOSEC_AI_BASE_URL` : (facultatif) variable d'environnement
alternative à `ai-base-url`
- `ai-skip-ssl` : (facultatif) ignorer la vérification du certificat SSL
pour l'API d'IA (utile pour les certificats auto-signés)
> 🎁 **[Atlas Cloud](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=gosec)** est une plateforme d'inférence d'IA multimodale complète qui offre aux développeurs une API d'IA unique pour accéder à la génération de vidéos, la génération d'images et aux API de LLM. Au lieu de gérer de multiples intégrations de fournisseurs, vous vous connectez une seule fois et obtenez un accès unifié à plus de 300 modèles sélectionnés dans toutes les modalités.
>
> Découvrez la nouvelle promotion du plan de codage d'Atlas Cloud pour un accès API plus économique : [https://www.atlascloud.ai/console/coding-plan](https://www.atlascloud.ai/console/coding-plan)
**Exemples :**
```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 \
./...
```
### Annoter le code
Comme avec tous les outils de détection automatisée, il y aura des cas de
faux positifs. Dans les cas où gosec signale un échec qui
a été vérifié manuellement comme étant sûr, il est possible
d'annoter le code avec un commentaire commençant par `#nosec`.
Le commentaire `#nosec` doit avoir le format
`#nosec [RuleList] [-- Justification]`.
Le commentaire `#nosec` doit être placé sur la ligne où
l'avertissement est signalé.
```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)
}
}
```
Lorsqu'un faux positif spécifique a été identifié et vérifié
comme sûr, vous pouvez souhaiter supprimer uniquement cette règle
unique (ou un ensemble spécifique de règles) au sein d'une section de code, tout
en continuant à analyser d'autres problèmes. Pour ce faire, vous pouvez lister
la ou les règles à supprimer dans l'annotation `#nosec`,
par exemple : `/* #nosec G401 */` ou `//#nosec G201 G202 G203`
Vous pouvez ajouter le texte de description ou de justification pour
l'annotation. La justification doit se trouver après la ou les règles à
supprimer et commencer par deux tirets ou plus,
par exemple : `//#nosec G101 G102 -- This is a false positive`
Alternativement, gosec prend également en charge la directive `//gosec:disable`,
qui fonctionne de manière similaire à `#nosec` :
```go
//gosec:disable G101 -- This is a false positive
```
Dans certains cas, vous pouvez également souhaiter revenir sur les endroits où des annotations `#nosec` ou `//gosec:disable` ont été utilisées. Pour exécuter le scanner et ignorer toutes les annotations `#nosec`, vous pouvez procéder comme suit :
```bash
gosec -nosec=true ./...
```
#### Exiger des ID de règle et des justifications
Pour éviter que les annotations ne suppriment par inadvertance des
règles non concernées, ou ne soient ajoutées sans explication, gosec accepte
deux options facultatives. Les deux sont désactivées par défaut (`false`), de sorte que les
bases de code existantes continuent de fonctionner sans modification.
- `-nosec-require-rules` rejette les directives `#nosec` /
`//gosec:disable` nues qui ne listent aucun ID de règle.
- `-nosec-require-justification` rejette les directives qui ne
comportent pas de `-- justification` après la liste des règles.
Lorsqu'elles sont activées, une directive qui échoue au contrôle ne supprime
plus aucun résultat et est signalée comme une erreur dans la
sortie, aux côtés de tout problème sous-jacent sur la ligne.
```bash
gosec -nosec-require-rules -nosec-require-justification ./...
```
Les mêmes options peuvent être définies via le bloc de configuration global :
```json
{
"global": {
"nosec-require-rules": "enabled",
"nosec-require-justification": "enabled"
}
}
```
### Suivi des suppressions
Comme décrit ci-dessus, nous pouvons supprimer des violations de manière externe
(à l'aide de `-include`/`-exclude`) ou en ligne (à l'aide d'annotations `#nosec`).
Les métadonnées de suppression peuvent être émises à des fins d'audit.
Activez le suivi des suppressions avec `-track-suppressions` :
```bash
gosec -track-suppressions -exclude=G101 \
-fmt=sarif -out=results.sarif ./...
```
- Pour les suppressions externes, gosec enregistre les informations de suppression
où `kind` vaut `external` et `justification` vaut
`Globally suppressed.`.
- Pour les suppressions en ligne, gosec enregistre les informations de suppression
où `kind` vaut `inSource` et `justification` correspond au texte
situé après deux tirets ou plus dans le commentaire.
**Remarque :** Seuls les formats SARIF et JSON prennent en charge le suivi
des suppressions.
### Balises de build
gosec est capable de transmettre vos
[balises de build Go](https://pkg.go.dev/go/build/) à l'analyseur.
Elles peuvent être fournies sous forme de liste séparée par des virgules comme suit :
```bash
gosec -tags debug,ignore ./...
```
### Formats de sortie
gosec prend en charge `text`, `json`, `yaml`, `csv`, `junit-xml`,
`html`, `sonarqube`, `golint` et `sarif`. Par défaut,
les résultats sont rapportés sur stdout, mais peuvent également être écrits dans
un fichier de sortie. Le format de sortie est contrôlé par le flag `-fmt`,
et le fichier de sortie est contrôlé par le flag `-out` comme
suit :
```bash
# Write output in json format to results.json
$ gosec -fmt=json -out=results.json *.go
```
Utilisez `-stdout` pour afficher les résultats tout en écrivant dans `-out`.
Utilisez `-verbose` pour remplacer le format stdout tout en préservant le
format du fichier.
```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
```
**Remarque :** gosec génère le
[format d'importation de problèmes génériques](https://docs.sonarqube.org/latest/analysis/generic-issue/)
pour SonarQube, et un rapport doit être importé dans SonarQube
à l'aide de
`sonar.externalIssuesReportPaths=path/to/gosec-report.json`.
## Modèles d'utilisation courants
```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 ./...
```
## Développement
La documentation de développement a été déplacée vers
[DEVELOPMENT.md](https://github.com/securego/gosec/blob/master/DEVELOPMENT.md).
## Qui utilise gosec ?
Voici une [liste](https://github.com/securego/gosec/blob/master/USERS.md) de certains utilisateurs de gosec.
## Sponsors
Soutenez ce projet en devenant sponsor. Votre logo
apparaîtra ici avec un lien vers votre site web
<a href="https://github.com/mercedes-benz" target="_blank"><img src="https://assets.kitploit.com/production/public/readmes/2947/08b6f9da5faff0e986172b0c77fed0865a2cb26e6f8c58a8ae588c74bcf16f5f.png"></a>