securego/gosecGo-Sicherheitsprüfer
# gosec - Go Security Checker
Untersucht Quellcode auf Sicherheitsprobleme, indem der Go-AST
und die SSA-Codedarstellung gescannt werden.
<img src="https://assets.kitploit.com/production/public/readmes/2947/83d294db3a312bcea542b6eb8261128e6f09b50a95271788fe301e164b1655b1.png" width="320">
## Schnellzugriffe
- [GitHub Action](#github-action)
- [Lokale Installation](#local-installation)
- [Schnellstart](#quick-start)
- [Häufige Nutzungsmuster](#common-usage-patterns)
- [Regeln auswählen](#selecting-rules)
- [Ausgabeformate](#output-formats)
## Funktionen
- **Musterbasierte Regeln** zur Erkennung häufiger Sicherheitsprobleme
in Go-Code
- **SSA-basierte Analysatoren** für Typkonvertierungen, 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 (die „License").
Sie dürfen diese Datei nur in Übereinstimmung mit der License verwenden.
Eine Kopie der License erhalten Sie
[hier](http://www.apache.org/licenses/LICENSE-2.0).
## Projektstatus
[](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
Sie können `gosec` wie folgt als GitHub Action ausführen:
Verwenden Sie das versionierte Tag mit `@master`, das an die
neueste stabile Version gebunden ist. Dies gewährleistet 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: ./...
```
#### Projekte mit privaten Modulen scannen
Wenn Ihr Projekt private Go-Module importiert, müssen Sie die
Authentifizierung konfigurieren, damit `gosec` die
Abhängigkeiten abrufen kann. Legen Sie die folgenden Umgebungsvariablen in
Ihrem Workflow fest:
- `GOPRIVATE`: Eine durch Kommas getrennte 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 Repositories.
```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 in die Code-Scanning
Sie können [Code-Analyse-Tools von Drittanbietern](https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/integrating-with-code-scanning)
in das GitHub-Code-Scanning integrieren, indem Sie Daten als SARIF-Dateien hochladen.
Der Workflow zeigt ein Beispiel für die Ausführung von `gosec` als Schritt
in einem GitHub-Action-Workflow, der die Datei `results.sarif`
ausgibt. Anschließend lädt der Workflow die Datei `results.sarif` mit der
Aktion `upload-sarif` zu GitHub hoch.
```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` stellt einen
[`golang.org/x/tools/go/analysis.Analyzer`](https://pkg.go.dev/golang.org/x/tools/go/analysis)
für die Integration mit Tools bereit, die die standardmäßige Go-Analyseschnittstelle
unterstützen, wie etwa BazeIs
[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 erfordert 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 ./...
```
### Exit-Codes
- `0`: Scan ohne nicht unterdrückte Befunde/Fehler abgeschlossen
- `1`: mindestens ein nicht unterdrückter Befund oder Verarbeitungsfehler
- Verwenden Sie `-no-fail`, um immer `0` zurückzugeben
## Verwendung
Gosec kann so konfiguriert werden, dass nur eine Teilmenge der Regeln ausgeführt wird, bestimmte Dateipfade ausgeschlossen werden und Berichte in verschiedenen Formaten erzeugt werden. Standardmäßig werden alle Regeln gegen die angegebenen Eingabedateien ausgeführt. Um rekursiv ab dem aktuellen Verzeichnis zu scannen, können Sie `./...` als Eingabeargument angeben.
### Verfügbare Regeln
gosec enthält Regeln aus diesen Kategorien:
- `G1xx`: allgemeine Probleme bei sicherem Coding (zum Beispiel fest codierte Anmeldedaten, unsichere Verwendung, HTTP-Härtung, Cookie-Sicherheit)
- `G2xx`: Injektionsrisiken bei der Konstruktion von Abfragen/Templates/Befehlen
- `G3xx`: Risiken bei Datei- und Pfadverarbeitung (Berechtigungen, Traversal, temporäre Dateien, Archiv-Extraktion)
- `G4xx`: Schwächen in Krypto und TLS
- `G5xx`: blockierte Importe
- `G6xx`: Go-spezifische Korrektheits-/Sicherheitsprüfungen (zum Beispiel 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](https://github.com/securego/gosec/blob/master/RULES.md).
### Ausgemusterte Regeln
- G105: Audit der Verwendung von math/big.Int.Exp -
[CVE ist behoben](https://github.com/golang/go/issues/15184)
- G307: Verzögern (Defer) einer Methode, die einen Fehler zurückgibt - verursacht mehr Unannehmlichkeiten als das Beheben eines Sicherheitsproblems, trotz der Details aus diesem
[Blogbeitrag](https://www.joeshaw.org/dont-defer-close-on-writable-files/)
### Regeln auswählen
Standardmäßig führt gosec alle Regeln gegen die angegebenen Dateipfade aus. Es ist jedoch möglich, über das Flag `-include=` eine Teilmenge der auszuführenden Regeln auszuwählen oder über das Flag `-exclude=` eine Menge von Regeln explizit 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
Jedes von `gosec` erkannte Problem wird einer
[CWE (Common Weakness Enumeration)](http://cwe.mitre.org/data/index.html)
zugeordnet, die 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 kann in einer Konfigurationsdatei
wie folgt bereitgestellt werden:
```JSON
{
"global": {
"nosec": "enabled",
"audit": "enabled"
}
}
```
- `nosec`: Diese Einstellung überschreibt alle `#nosec`-Direktiven, die im gesamten Codebestand definiert sind
- `audit`: Läuft im Audit-Modus, der zusätzliche Prüfungen aktiviert, die für die normale Codeanalyse möglicherweise zu aufdringlich wären
```bash
# Run with a global configuration file
$ gosec -conf config.json .
```
### Pfadbasierte Regelausschlüsse
Große Repositories mit mehreren Komponenten können unterschiedliche
Sicherheitsregeln für unterschiedliche Pfade benötigen. 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, der auf Dateipfade abgeglichen 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-Runtime-Version zurückgegriffen.
Die Go-Modulversion wird mit dem Befehl `go list` ermittelt,
was in einigen Fällen zu Leistungseinbußen führen kann. In
dieser Situation kann die Go-Modulversion einfach durch
Setzen der Umgebungsvariable
`GOSECGOVERSION=go1.21.1` angegeben werden.
### Abhängigkeiten
gosec lädt Pakete mithilfe von Go-Modulen. In den meisten Projekten
werden Abhängigkeiten während des Scannens automatisch aufgelöst.
Wenn Abhängigkeiten fehlen, führen Sie Folgendes aus:
```bash
go mod tidy
go mod download
```
### Testdateien und -ordner ausschließen
gosec ignoriert Testdateien in allen Paketen und alle
Abhängigkeiten in Ihrem Vendor-Verzeichnis.
Das Scannen von Testdateien kann mit dem folgenden
Flag aktiviert werden:
```bash
gosec -tests ./...
```
Zusätzliche Ordner können wie folgt ausgeschlossen werden:
```bash
gosec -exclude-dir=rules -exclude-dir=cmd ./...
```
### Generierte Dateien ausschließen
gosec kann generierte Go-Dateien anhand des standardmäßigen Kommentars für generierten Code ignorieren.
```
// Code generated by some generator DO NOT EDIT.
```
```bash
gosec -exclude-generated ./...
```
### Automatisches Beheben von Schwachstellen
gosec kann auf Basis von KI-Empfehlungen Korrekturvorschläge machen. Dazu
ruft es eine KI-API auf, um einen Vorschlag für einen Sicherheitsbefund 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](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=gosec)
- **Gemini**: `gemini-3.1-pro-preview` (Standard),
`gemini-2.5-pro`, `gemini-2.5-flash`,
`gemini-2.5-flash-lite`
- **Claude**: `claude-sonnet-4-6` (Standard),
`claude-opus-4-7`, `claude-opus-4-6`,
`claude-sonnet-4-5`, `claude-opus-4-5`,
`claude-haiku-4-5`
- **OpenAI**: `gpt-5.4` (Standard), `gpt-5.4-mini`,
`gpt-5.4-nano`
- **Benutzerdefiniert OpenAI-kompatibel**: Jeder benutzerdefinierte Modellname
(erfordert `ai-base-url`)
- `ai-api-key` oder setzen Sie die Umgebungsvariable
`GOSEC_AI_API_KEY`: der Schlüssel für den Zugriff auf die KI-API
- Für Gemini können Sie einen API-Schlüssel gemäß
[dieser Anleitung](https://ai.google.dev/gemini-api/docs/api-key) erstellen
- Für Claude erhalten Sie Ihren API-Schlüssel in der
[Anthropic Console](https://console.anthropic.com/)
- Für OpenAI erhalten Sie Ihren API-Schlüssel auf der
[OpenAI Platform](https://platform.openai.com/api-keys)
- `ai-base-url`: (optional) benutzerdefinierte Basis-URL für
OpenAI-kompatible APIs (z. B. Azure OpenAI, LocalAI,
Ollama)
- Atlas Cloud verwendet standardmäßig `https://api.atlascloud.ai/v1`,
daher ist `ai-base-url` für den integrierten `atlas`-Anbieter
optional
- `GOSEC_AI_PROVIDER`: (optional) Umgebungsvariable
als Alternative zu `ai-api-provider`
- `GOSEC_AI_BASE_URL`: (optional) Umgebungsvariable
als Alternative zu `ai-base-url`
- `ai-skip-ssl`: (optional) SSL-Zertifikatsprüfung für die KI-API
überspringen (nützlich für selbstsignierte Zertifikate)
> 🎁 **[Atlas Cloud](https://www.atlascloud.ai/?utm_source=github&utm_medium=link&utm_campaign=gosec)** ist eine vollmodale KI-Inferenzplattform, die Entwicklern eine einzige KI-API für den Zugriff auf Videogenerierung, Bildgenerierung und LLM-APIs bietet. Statt mehrere Anbieterintegrationen zu verwalten, verbinden Sie sich einmal und erhalten einheitlichen Zugriff auf über 300 kuratierte Modelle aller Modalitäten.
>
> Sehen Sie sich die neue Coding-Plan-Aktion von Atlas Cloud für budgetfreundlicheren API-Zugriff an: [https://www.atlascloud.ai/console/coding-plan](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.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 \
./...
```
### Code annotieren
Wie bei allen automatisierten Erkennungswerkzeugen wird es Fälle von
False Positives geben. In Fällen, in denen gosec einen Fehler meldet,
der manuell als sicher verifiziert wurde, ist es möglich,
den Code mit einem Kommentar zu annotieren, der mit `#nosec` beginnt.
Der `#nosec`-Kommentar sollte das Format
`#nosec [RuleList] [-- Justification]` 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 bestimmter Fehlalarm identifiziert und als sicher
verifiziert wurde, möchten Sie möglicherweise nur diese einzelne Regel (oder
eine bestimmte Gruppe von Regeln) innerhalb eines Codeabschnitts unterdrücken, während
die Suche nach anderen Problemen fortgesetzt wird. Dazu können Sie die
zu unterdrückende(n) Regel(n) innerhalb der `#nosec`-Annotation auflisten,
z. B.: `/* #nosec G401 */` oder `//#nosec G201 G202 G203`
Sie können den Beschreibungs- oder Begründungstext für die
Annotation angeben. Die Begründung sollte nach der/den zu
unterdrückenden Regel(n) 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 einigen Fällen möchten Sie vielleicht auch Stellen erneut überprüfen, an denen
`#nosec`- oder `//gosec:disable`-Annotationen verwendet wurden. Um
den Scanner auszuführen und alle `#nosec`-Annotationen zu ignorieren, können Sie
wie folgt vorgehen:
```bash
gosec -nosec=true ./...
```
#### Erfordern von Regel-IDs und Begründungen
Um zu verhindern, dass Anmerkungen versehentlich unabhängige
Regeln unterdrücken oder ohne Erklärung hinzugefügt werden, akzeptiert gosec
zwei Opt-in-Flags. Beide sind standardmäßig auf `false` gesetzt, sodass bestehende
Codebasen unverändert weiter funktionieren.
- `-nosec-require-rules` lehnt nackte `#nosec` /
`//gosec:disable`-Direktiven ab, die keine Regel-ID auflisten.
- `-nosec-require-justification` lehnt Direktiven ab, die
keine `-- justification` nach der Regelliste enthalten.
Wenn aktiviert, unterdrückt eine Direktive, die die Prüfung nicht besteht, keine
Befunde mehr und wird als Fehler in der
Ausgabe gemeldet, zusammen mit dem zugrunde liegenden Problem in der Zeile.
```bash
gosec -nosec-require-rules -nosec-require-justification ./...
```
Dieselben Optionen können über den globalen Konfigurationsblock festgelegt werden:
```json
{
"global": {
"nosec-require-rules": "enabled",
"nosec-require-justification": "enabled"
}
}
```
### Unterdrückungen nachverfolgen
Wie oben beschrieben, können wir Verstöße extern unterdrücken
(mit `-include`/`-exclude`) oder inline (mit `#nosec`-
Annotationen). Unterdrückungsmetadaten können zur Prüfung ausgegeben werden.
Aktivieren Sie die Unterdrückungsverfolgung mit `-track-suppressions`:
```bash
gosec -track-suppressions -exclude=G101 \
-fmt=sarif -out=results.sarif ./...
```
- Bei externen Unterdrückungen zeichnet gosec Unterdrückungsinformationen auf,
wobei `kind` `external` und `justification`
`Globally suppressed.` ist.
- Bei Inline-Unterdrückungen zeichnet gosec Unterdrückungsinformationen auf,
wobei `kind` `inSource` und `justification` der Text
nach zwei oder mehr Bindestrichen im Kommentar ist.
**Hinweis:** Nur die Formate SARIF und JSON unterstützen die Verfolgung
von Unterdrückungen.
### Build-Tags
gosec ist in der Lage, Ihre
[Go-Build-Tags](https://pkg.go.dev/go/build/) an den Analyzer weiterzugeben.
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 stdout ausgegeben, können aber auch in
eine Ausgabedatei geschrieben werden. Das Ausgabeformat wird über das
Flag `-fmt` gesteuert, und die Ausgabedatei wird über das Flag `-out`
wie folgt gesteuert:
```bash
# Write output in json format to results.json
$ gosec -fmt=json -out=results.json *.go
```
Verwenden Sie `-stdout`, um Ergebnisse auszugeben und gleichzeitig `-out` zu schreiben.
Verwenden Sie `-verbose`, um das stdout-Format zu überschreiben und dabei das
Dateiformat beizubehalten.
```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
[generische Issue-Importformat](https://docs.sonarqube.org/latest/analysis/generic-issue/)
für SonarQube, und ein Bericht muss in SonarQube
mit
`sonar.externalIssuesReportPaths=path/to/gosec-report.json` importiert werden.
## 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 nach
[DEVELOPMENT.md](https://github.com/securego/gosec/blob/master/DEVELOPMENT.md) verschoben.
## Wer verwendet gosec?
Dies ist eine [Liste](https://github.com/securego/gosec/blob/master/USERS.md) mit einigen der Nutzer von gosec.
## Sponsoren
Unterstützen Sie dieses Projekt, indem Sie Sponsor werden. Ihr Logo wird
hier mit einem Link zu Ihrer Website angezeigt
<a href="https://github.com/mercedes-benz" target="_blank"><img src="https://assets.kitploit.com/production/public/readmes/2947/08b6f9da5faff0e986172b0c77fed0865a2cb26e6f8c58a8ae588c74bcf16f5f.png"></a>