Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
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.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
Tools/GitHubGitHub/praetorian-inc/capability-sdk
DefensivwerkzeugeStatische AnalyseSchwachstellenscannerScripting & AutomatisierungSicherheitsvirtualisierungDevSecOpsDienstprogramme & Frameworks
GitHub
Teilen
praetorian-inc/capability-sdk

capability-sdk

Gemeinsames Go-SDK, das eine standardisierte Fähigkeitsschnittstelle für Sicherheitsscanner definiert, mit Ausgabe von Findings in mehreren Formaten (Terminal, JSON, NDJSON, Markdown, SARIF) und Prüfungen auf Abweichungen in der CLI-Dokumentation.

Repository anzeigen
133vor 3 TagenNoch nicht geprüft

Capability SDK

Gemeinsames Go-SDK zum Erstellen von Sicherheitsfähigkeiten für die Guard-Plattform.

Pakete

pkg/capability - Capability-Schnittstelle

Definiert die standardisierte Schnittstelle, die Sicherheitsscanner implementieren.

Typen:

// Target - was eine Capability scannt
type Target struct {
    Type  TargetType        // domain, ip, port, url, cloud_resource
    Value string            // Der Zielwert
    Meta  map[string]string // Zusätzlicher Kontext
}

// Finding - was eine Capability entdeckt
type Finding struct {
    Type     FindingType    // asset, risk, attribute
    Severity Severity       // info, low, medium, high, critical
    Data     map[string]any // Flexible Nutzlast
}

// Capability - die zu implementierende Schnittstelle
type Capability interface {
    Name() string
    Run(ctx context.Context, target Target) ([]Finding, error)
}

Beispielimplementierung:

type SubdomainScanner struct{}

func (s *SubdomainScanner) Name() string {
    return "subdomain-scanner"
}

func (s *SubdomainScanner) Run(ctx context.Context, target capability.Target) ([]capability.Finding, error) {
    if target.Type != capability.TargetDomain {
        return nil, fmt.Errorf("expected domain, got %s", target.Type)
    }

    // Scan logic here...

    return []capability.Finding{
        {
            Type: capability.FindingAsset,
            Data: map[string]any{
                "dns":   "found.example.com",
                "class": "domain",
            },
        },
    }, nil
}

pkg/formatter - Ausgabeformatierung

Multi-Format-Ausgabesystem zum Rendern von Scan-Ergebnissen.

Unterstützte Formate:

  • Terminal (streaming, farbig via lipgloss)
  • JSON (gepuffert, Pretty-Print-Option)
  • NDJSON (streaming, zeilengetrennt)
  • Markdown (gepuffert, template-basierte Berichte)
  • SARIF 2.1.0 (gepuffert, GitHub/Azure-Integration)

Grundlegende Verwendung:

import "github.com/praetorian-inc/capability-sdk/pkg/formatter"

// Create a formatter
f, err := formatter.New(formatter.Config{
    Format: formatter.FormatJSON,
    Writer: os.Stdout,
    Pretty: true,
})
if err != nil {
    return err
}
defer f.Close()

// Format findings
f.Format(ctx, formatter.Finding{
    ID:       "vuln-001",
    Title:    "Security Issue",
    Severity: formatter.SeverityHigh,
})

// Complete with summary
f.Complete(ctx, formatter.Summary{TotalFindings: 1, HighCount: 1})

Konvertieren von Capability-Findings:

import (
    "github.com/praetorian-inc/capability-sdk/pkg/capability"
    "github.com/praetorian-inc/capability-sdk/pkg/formatter"
)

// Run capability
findings, err := scanner.Run(ctx, target)

// Convert and format for CLI output
for _, cf := range findings {
    ff := formatter.FromCapabilityFinding(cf)
    f.Format(ctx, ff)
}

Multi-Ausgabe (TeeFormatter):

terminal, _ := formatter.New(formatter.Config{Format: formatter.FormatTerminal, Writer: os.Stdout})
jsonFile, _ := formatter.New(formatter.Config{Format: formatter.FormatJSON, Writer: file})

tee, _ := formatter.NewTee(terminal, jsonFile)
tee.Format(ctx, finding) // Writes to both

Parallele Übermittlung (Aggregator):

agg := formatter.NewAggregator(f, 100) // buffer size 100

// From multiple goroutines
go func() { agg.Submit(ctx, finding1) }()
go func() { agg.Submit(ctx, finding2) }()

agg.Close() // Wait for all writes

pkg/clisurface - CLI-Dokumentations-Drift-Gate

Durchläuft einen Cobra-Befehlbaum und generiert, fügt zusammen und prüft die daraus erstellten Dokumentationsartefakte, sodass committete Dokumente nicht stillschweigend vom Binary abweichen können. Erstellen Sie ein Docs mit clisurface.New, verwenden Sie dann Docs.Write zum Neugenerieren und Docs.CheckArtifacts plus Docs.LintRepo, um CI fehlschlagen zu lassen, wenn die committeten Dateien, Prosa oder Go-Kommentare nicht mehr mit der CLI übereinstimmen. Siehe go doc ./pkg/clisurface für die vollständige API.

Architektur

┌─────────────────────────────────────────────────────────────────────┐
│                     STANDALONE TOOL                                 │
│  Implements: capability.Capability                                  │
│  Produces:   []capability.Finding                                   │
└────────────────────────────┬────────────────────────────────────────┘
                             │
              ┌──────────────┴──────────────┐
              ▼                              ▼
┌─────────────────────────┐    ┌─────────────────────────────-────────┐
│   CLI OUTPUT PATH       │    │       CHARIOT INTEGRATION PATH       │
│                         │    │                                      │
│  capability.Finding     │    │  capability.Finding                  │
│         │               │    │         │                            │
│         ▼               │    │         ▼                            │
│  formatter.Finding      │    │  Chariot Adapter (in chariot repo)   │
│  (FromCapabilityFinding)│    │         │                            │
│         │               │    │         ▼                            │
│         ▼               │    │  Tabularium Model (Asset/Risk/Attr)  │
│  Terminal/JSON/SARIF    │    │         │                            │
│                         │    │         ▼                            │
│     stdout/file         │    │     job.Send() → Storage             │
└─────────────────────────┘    └───────────────────────────────-──────┘

Typen erweitern

Hinzufügen eines neuen Zieltyps

  1. Issue eröffnen: "Need git_repo target type for X"
  2. Backend-Entwickler prüft Tabularium-Mapping
  3. Zu pkg/capability/target.go hinzufügen:
    TargetGitRepo TargetType = "git_repo"
    
  4. Valid()-Methode aktualisieren
  5. Tests hinzufügen
  6. Chariot-Adapter aktualisieren

Hinzufügen eines neuen Finding-Typs

  1. Issue eröffnen: "Need relationship finding type for X"
  2. Data-Schema definieren
  3. Zu pkg/capability/finding.go hinzufügen
  4. Konverter in pkg/formatter/capability_converter.go aktualisieren
  5. Tests hinzufügen

Module, die dieses SDK verwenden

  • diocletian - Cloud-Sicherheitsscanner

Lizenz

Apache License 2.0. Siehe LICENSE.

Die Lizenz wird einmalig im Repository-Stamm angegeben. Fügen Sie keine urheberrechtlichen oder lizenzrechtlichen Header pro Datei hinzu — auch nicht beim Portieren von Code aus einem Schwesterprojekt, das solche Header enthält. Eine LICENSE im Stammverzeichnis ist die maßgebliche Erklärung; es ist nicht erforderlich, sie in jeder Datei zu wiederholen.

Tool herunterladen

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    708
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    500
  • 3

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    398
  • 4

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    341
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    259
  • 6

    antifox

    antifox-ai/antifox

    KI-Multi-Agenten-Plattform für autonome Penetrationstests, die Recon, Angriffsflächen-Erkennung, Exploit-Validierung und evidenzbasierte Berichtserstellung durchführt.

    257

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →