Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
legitify — Erkennen und beheben Sie Fehlkonfigurationen und Sicherheitsrisiken in all Ihren GitHub- und GitLab-Assets. | Kitploit
Tools/GitHubGitHub/legit-labs/legitify
SchwachstellenscannerKonfigurationsprüfungCloud-SicherheitDevSecOpsLieferkettensicherheitFehlkonfiguration
GitHublegit-labs/legitify

legitify

Erkennen und beheben Sie Fehlkonfigurationen und Sicherheitsrisiken in all Ihren GitHub- und GitLab-Assets.

Repository anzeigen
880782vor 1 JahrVon Kitploit geprüft
Webseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

Build & Test Code Analysis Version Releaser Build Docs Go Report Card
Legitify Logo

Stärken Sie die Sicherheitslage Ihres Quellcode-Managements!
Erkennen und beheben Sie Fehlkonfigurationen, Sicherheits- und Compliance-Probleme in all Ihren GitHub- und GitLab-Assets mit Leichtigkeit 🔥
von Legit Security.

Sie fragen sich, was Legit Security macht?

Legit Security ist eine Anwendungssicherheits-Posture-Management- (ASPM) und Software-Lieferkettensicherheitslösung.
Weitere Informationen finden Sie in der Vergleichstabelle

https://user-images.githubusercontent.com/107790206/210602039-2d022692-87ea-4005-b9c6-f091158de3ce.mov

Installation

Die Installation ist auf verschiedene Arten möglich:

  • Für macOS (oder Linux) mit homebrew:
root@kitploit:~
brew install legitify
  • Sie können die neueste legitify-Version von https://github.com/Legit-Labs/legitify/releases herunterladen. Jedes Archiv enthält:

    • Legitify-Binärdatei für die gewünschte Plattform
    • Integrierte Richtlinien von Legit Security
  • Aus dem Quellcode mit den folgenden Schritten:

root@kitploit:~
git clone [email protected]:Legit-Labs/legitify.git
go run main.go analyze ...
  • Als GitHub CLI-Erweiterung (siehe https://github.com/Legit-Labs/gh-legitify für weitere Informationen)
root@kitploit:~
gh extension install legit-labs/gh-legitify
gh legitify

CI - Legitify Custom GitHub Action

Sie können legitify als Teil eines CI-Prozesses mit den legitify Custom GitHub Actions ausführen:

root@kitploit:~
name: Legitify Analyze
on:
    workflow_dispatch:
    schedule:
      - cron: '0 11 * * 1-5'

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - name: Legitify Action
        uses: Legit-Labs/legitify@main
        with:
          github_token: ${{ secrets.PAT_FOR_LEGITIFY }}
          ignore-policies: |
             non_admins_can_create_public_repositories
             requires_status_checks

Sehen Sie sich die Aktionsdatei für zusätzliche Parameter und Konfiguration an.

Provenienz

Um die Sicherheit der Software-Lieferkette der legitify-Benutzer zu verbessern, enthält jede legitify-Version ab v0.1.6 ein SLSA Level 3 Provenienz-Dokument.
Das Provenienzdokument bezieht sich auf alle Artefakte im Release sowie auf das generierte Docker-Image.
Sie können den offiziellen Verifizierer des SLSA-Frameworks verwenden, um die Provenienz zu überprüfen.
Beispiel für die Verwendung unter der Architektur darwin_arm64 für das Release v0.1.6:

root@kitploit:~
VERSION=0.1.6
ARCH=darwin_arm64
./slsa-verifier verify-artifact --source-branch main --builder-id 'https://github.com/slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@refs/tags/v1.2.2' --source-uri "git+https://github.com/Legit-Labs/legitify" --provenance-path multiple.intoto.jsonl ./legitify_${VERSION}_${ARCH}.tar.gz

Befehle

analyze

root@kitploit:~
SCM_TOKEN=<your_token> legitify analyze

Standardmäßig überprüft legitify die Richtlinien gegen alle Ihre Ressourcen (Organisationen, Repositorys, Mitglieder, Aktionen). Archivierte Repositorys werden übersprungen.

Sie können steuern, welche Ressourcen analysiert werden, mit den Befehlszeilen-Flags namespace und org:

  • --namespace (-n): Analysiert Richtlinien, die sich auf die angegebenen Ressourcen beziehen
  • --org: Beschränkt die Analyse auf die angegebenen GitHub-Organisationen oder GitLab-Gruppen, unter Ausschluss archivierter Repositorys
  • --repo: Beschränkt die Analyse auf die angegebenen GitHub-Repositorys oder GitLab-Projekte
  • --scm: Gibt die Quellcodeverwaltungsplattform an. Mögliche Werte sind: github oder gitlab. Standard ist github. Bitte beachten: Bei Ausführung mit GitLab ist --scm gitlab erforderlich.
  • --enterprise: Gibt an, welche Unternehmen analysiert werden sollen. Bitte beachten: Um ein Unternehmen zu analysieren, muss ein Unternehmens-Slug angegeben werden.
root@kitploit:~
SCM_TOKEN=<your_token> legitify analyze --org org1,org2 --namespace organization,member

Der obige Befehl testet Organisations- und Mitgliederrichtlinien für org1 und org2.

gpt-analysis

root@kitploit:~
SCM_TOKEN=<your_token> OPENAI_TOKEN=<token> ./legitify gpt-analysis --repo org1/repo1 --org org1

GPT-3-basierte Analyse der Sicherheitslage des angegebenen Repositorys oder der Organisation.

HINWEIS: Die Metadaten des Repositorys/der Organisation werden an OpenAI-Server gesendet.

Flags:

  • --org: Schränkt die Analyse auf die angegebenen GitHub-Organisationen oder GitLab-Gruppen ein
  • --repo: Schränkt die Analyse auf die angegebenen GitHub-Repositorys oder GitLab-Projekte ein
  • --scm: Gibt die Quellcodeverwaltungsplattform an. Mögliche Werte: github oder gitlab. Standard: github.
  • --token: Token für die SCM (oder setzen Sie die Umgebungsvariable SCM_TOKEN)
  • --openai-token: Token für die OpenAI-API (oder setzen Sie die Umgebungsvariable OPENAI_TOKEN)

Es muss entweder --org oder --repo oder beides angegeben werden.

OpenAI-Token generieren:

  1. Gehen Sie zu https://beta.openai.com/signup und erstellen Sie ein OpenAI-Konto.
  2. Klicken Sie unter https://platform.openai.com/account/api-keys auf "Create new secret key".

Verwendung mit GitHub Actions

Sie können legitify auch als GitHub Action in Ihren Workflows ausführen. Im Verzeichnis action_examples finden Sie konkrete Beispiele.

Anforderungen

GitHub (Cloud und Enterprise Server)

  1. Um legitify optimal nutzen zu können, müssen Sie Inhaber mindestens einer GitHub-Organisation sein. Andernfalls können Sie das Tool weiterhin verwenden, wenn Sie Administrator mindestens eines Repositorys innerhalb einer Organisation sind. In diesem Fall werden nur repositorybezogene Richtlinienergebnisse angezeigt.
  2. legitify benötigt ein persönliches Zugriffstoken (PAT) von GitHub, um Ihre Ressourcen erfolgreich zu analysieren. Dies kann entweder als Argument (-t) oder als Umgebungsvariable (SCM_TOKEN) bereitgestellt werden. Der PAT benötigt die folgenden Bereiche für eine vollständige Analyse:
root@kitploit:~
admin:org, read:enterprise, admin:org_hook, read:org, repo, read:repo_hook

Siehe Erstellen eines persönlichen Zugriffstokens für weitere Informationen.
Fein abgestufte persönliche Zugriffstoken werden derzeit nicht unterstützt.

GitHub Enterprise Server

Sie können legitify gegen eine GitHub Enterprise Server-Instanz ausführen, indem Sie die Endpunkt-URL in der Umgebungsvariable SERVER_URL setzen:

root@kitploit:~
export SERVER_URL="https://github.example.com/"
SCM_TOKEN=<your_token> legitify analyze --org org1,org2 --namespace organization,member

GitLab Cloud/Server

  1. Wie im vorherigen Abschnitt erwähnt, müssen Sie Inhaber mindestens einer GitLab-Gruppe sein. Andernfalls können Sie das Tool weiterhin verwenden, wenn Sie Administrator mindestens eines Projekts innerhalb einer Gruppe sind. In diesem Fall werden nur projektrelevante Richtlinienergebnisse angezeigt.
  2. legitify benötigt ein persönliches Zugriffstoken (PAT) von GitLab, um Ihre Ressourcen erfolgreich zu analysieren. Dies kann entweder als Argument (-t) oder als Umgebungsvariable (SCM_TOKEN) bereitgestellt werden. Der PAT benötigt die folgenden Bereiche für eine vollständige Analyse: read_api, read_user, read_repository, read_registry Siehe Erstellen eines persönlichen Zugriffstokens für weitere Informationen.
    Um legitify gegen GitLab Cloud auszuführen, setzen Sie das SCM-Flag auf gitlab --scm gitlab. Um gegen GitLab Server auszuführen, müssen Sie auch eine SERVER_URL angeben:
root@kitploit:~
export SERVER_URL="https://gitlab.example.com/"
SCM_TOKEN=<your_token> legitify analyze --namespace organization --scm gitlab

HINWEIS 1: Um ungültige Serverzertifikate zu ignorieren, übergeben Sie das Flag --ignore-invalid-certificate.

HINWEIS 2: Bei nicht-Premium GitLab-Konten werden einige Richtlinien (z. B. Branch-Schutzrichtlinien) übersprungen.

Namespaces

Namespaces in legitify sind Ressourcen, die gesammelt und gegen die Richtlinien geprüft werden. Derzeit werden die folgenden Namespaces unterstützt:

  1. organization - Richtlinien auf GitHub-Organisations- (oder GitLab-Gruppen-)Ebene (z. B. "Zwei-Faktor-Authentifizierung für die Organisation nicht erzwungen")
  2. actions - GitHub Actions-Richtlinien auf Organisationsebene (z. B. "GitHub Actions-Ausführungen sind nicht auf verifizierte Aktionen beschränkt")
  3. member - Richtlinien auf Mitwirkendenebene (z. B. "Veralteter Administrator gefunden")
  4. repository - Richtlinien auf GitHub-Repository- (oder GitLab-Projekt-)Ebene (z. B. "Code-Review durch mindestens zwei Prüfer nicht erzwungen"). Hinweis: Archivierte Repositorys werden ignoriert, es sei denn, sie werden direkt über das --repo-Argument angegeben.
  5. runner_group - Runner-Gruppen-Richtlinien (z. B. "Runner kann von öffentlichen Repositorys verwendet werden")

Standardmäßig analysiert legitify alle Namespaces. Sie können die Analyse mit dem Flag --namespace auf ausgewählte Namespaces beschränken, gefolgt von einer kommagetrennten Liste der ausgewählten Namespaces.

Ausgabeoptionen

Standardmäßig gibt legitify die Ergebnisse in einem menschenlesbaren Format aus. Dies enthält die Liste der Richtlinienverstöße, nach Schweregrad sortiert, sowie eine nach Namespace sortierte Zusammenfassungstabelle.

Ausgabeformate

Mit dem Flag --output-format (-f) unterstützt legitify die Ausgabe der Ergebnisse in den folgenden Formaten:

  1. human-readable - Menschnlesbarer Text (Standard).
  2. json - Standard-JSON.
  3. sarif - SARIF-Format (Info).

Ausgabeschemata

Mit dem Flag --output-scheme unterstützt legitify die Ausgabe der Ergebnisse in verschiedenen Gruppierungsschemata. Hinweis: --output-format=json muss angegeben werden, um nicht standardmäßige Schemata auszugeben.

  1. flattened - Keine Gruppierung; eine flache Liste der Richtlinien, jede mit ihren Verstößen (Standard).
  2. group-by-namespace - Gruppiert die Richtlinien nach Namespace.
  3. group-by-resource - Gruppiert die Richtlinien nach ihrer Ressource, z. B. bestimmte Organisation/Repository.
  4. group-by-severity - Gruppiert die Richtlinien nach ihrem Schweregrad.

Ausgabeziele

  • --output-file - Vollständiger Pfad der Ausgabedatei (Standard: keine Ausgabedatei, Ausgabe auf stdout).
  • --error-file - Vollständiger Pfad der Fehlerprotokolle (Standard: ./error.log).

Farbgebung

Bei der Ausgabe in einem menschenlesbaren Format unterstützt legitify das übliche Flag --color[=when] mit den folgenden Optionen:

  • auto - Farbige Ausgabe, wenn stdout ein Terminal ist, ansonsten einfarbig (Standard).
  • always - Farbige Ausgabe unabhängig vom Ausgabeziel.
  • none - Einfarbige Ausgabe unabhängig vom Ausgabeziel.

Sonstiges

  • Verwenden Sie das Flag --failed-only, um bestandene/übersprungene Prüfungen aus dem Ergebnis zu filtern.
  • Verwenden Sie --ignore-policies-path $PATH und geben Sie eine Datei mit den Richtlinien an, die Sie ignorieren möchten, um bestimmte Richtlinien zu überspringen. Eine Richtlinie pro Zeile, z. B. no_conversation_resolution requires_status_checks

Scorecard-Unterstützung – nur für GitHub-Server/Cloud-Repositorys

Scorecard ist ein Open-Source-Projekt der OSSF:

Scorecards ist ein automatisiertes Tool, das eine Reihe wichtiger Heuristiken ("Checks") im Zusammenhang mit der Softwaresicherheit bewertet und jedem Check eine Punktzahl von 0-10 zuweist. Sie können diese Punktzahlen verwenden, um bestimmte Bereiche zu verstehen, die verbessert werden müssen, um die Sicherheitslage Ihres Projekts zu stärken. Sie können auch die Risiken bewerten, die Abhängigkeiten mit sich bringen, und fundierte Entscheidungen über die Akzeptanz dieser Risiken, die Bewertung alternativer Lösungen oder die Zusammenarbeit mit den Maintainern treffen, um Verbesserungen zu erzielen.

legitify unterstützt die Ausführung von Scorecard für alle Repositorys der Organisation, die Durchsetzung von Score-Richtlinien und die Anzeige der Ergebnisse mithilfe des Flags --scorecard:

  • no - Scorecard nicht ausführen (Standard).
  • yes - Scorecard ausführen und eine Richtlinie anwenden, die bei jedem Repository-Score unter 7,0 alarmiert.
  • verbose - Scorecard ausführen, eine Richtlinie anwenden, die bei jedem Repository-Score unter 7,0 alarmiert, und die Ausgabe in die legitify-Ausgabe einbetten.

legitify führt die folgenden Scorecard-Prüfungen durch:

PrüfungÖffentliches RepositoryPrivates Repository
Security-PolicyV
CII-Best-PracticesV
FuzzingV
LicenseV
Signed-ReleasesV
Branch-ProtectionVV
Code-ReviewVV
ContributorsVV
Dangerous-WorkflowVV
Dependency-Update-ToolVV
MaintainedVV
Pinned-DependenciesVV
SASTVV
Token-PermissionsVV
VulnerabilitiesVV
WebhooksVV

Richtlinien

legitify wird mit einer Reihe von Richtlinien für jedes SCM im Verzeichnis policies/ ausgeliefert.

Diese Richtlinien sind hier dokumentiert.

Beitrag

Vielen Dank, dass Sie darüber nachdenken, zu Legitify beizutragen! Wir ermutigen und schätzen jede Art von Beitrag. Hier sind einige Ressourcen, die Ihnen den Einstieg erleichtern:

  • Beitragsleitfaden
  • Verhaltenskodex
  • Ein Issue eröffnen
  • Einen Pull-Request öffnen

Support

Wenn Sie Fragen zu legitify haben oder Hilfe bei der Bedienung benötigen, zögern Sie nicht, uns zu kontaktieren. Unser Team ist bestrebt, Unterstützung zu bieten und ein reibungsloses Erlebnis zu gewährleisten.

Legitify vs. die Legit Security Plattform

Wenn Ihnen Legitify gefällt, werden Sie die Legit Security Plattform lieben!

  • Sie automatisiert Legitify-Prüfungen für die gesamte Umgebung, entdeckt weitere Systeme und zeigt alle Ergebnisse in einer einfachen Web-App zur skalierbaren Verwaltung.
  • Legit Security ist eine vollständige CI/CD-Sicherheitslösung zusammen mit Application Security Posture Management (ASPM), die die Anwendungssicherheit von Ende zu Ende abdeckt.
  • Es ist eine SaaS-Plattform, die für Engineering-, DevOps- und Sicherheitsteams entwickelt wurde und von vielen führenden Organisationen weltweit vertrauenswürdig ist.

Unten finden Sie einen Funktionsvergleich zwischen Legitify und Legit:

FunktionLegitifyLegit Security Plattform
Unterstützte PlattformenGitHub
GitLab
Alle großen SCMs (inkl. Azure DevOps, Bitbucket und mehr)
CI/CD-Systeme (z. B. Jenkins)
Paketregistries (z. B. JFrog Artifactory)
Cloud-Anbieter (z. B. AWS)
RisikoerkennungNur SCM-FehlkonfigurationenSCM-Fehlkonfigurationen
CI-Fehlkonfigurationen
CD-Fehlkonfigurationen
Paketregistrierungs-Fehlkonfigurationen
Pipeline-Risiken
Geheimnisse
IaC
Sicherheitsvorfälle
Und mehr...
Compliance-BerichtOSSF SCM Best PracticesSSDF
SLSA
SOC2
ISO 27001
FedRAMP
Und mehr...
Erkennung von RichtlinienabweichungenKann periodisch über die GitHub Action von Legitify erkannt werdenErhalten Sie Echtzeit-Benachrichtigungen, wenn eine Fehlkonfiguration eingeführt wird
SDLC-Asset-Management-Ja
Issue- und Richtlinienverwaltung-Ja
Code-to-Cloud-Kontext-Ja (kontextualisierte Informationen ermöglichen intelligentere Priorisierung)
Arbeitsbereiche und Produktgruppen-Ja
Ticketing & Alarmierung-Jira, Slack und mehr
Risikoaufnahme-Import-APIs und Integrationen mit SAST, SCA und anderen Testlösungen
REST-APIs-Ja

Um Legit kennenzulernen, besuchen Sie unsere Website oder buchen Sie direkt eine Demo

Legitify Logo
Tool herunterladen