Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/praetorian-inc/capability-sdk
Strumenti DifensiviAnalisi StaticaScanner di VulnerabilitàScripting e AutomazioneVirtualizzazione per la SicurezzaDevSecOpsUtilità e Framework
GitHub
Condividi
praetorian-inc/capability-sdk

capability-sdk

SDK Go condiviso che definisce un'interfaccia standard per le capacità degli scanner di sicurezza, con output dei risultati in formati multipli (terminale, JSON, NDJSON, Markdown, SARIF) e controlli di deriva della documentazione CLI.

Vedi Repository
1333 giorni faNon ancora revisionato

Capability SDK

SDK Go condiviso per la creazione di capability di sicurezza per la piattaforma Guard.

Pacchetti

pkg/capability - Interfaccia Capability

Definisce l'interfaccia standardizzata che gli scanner di sicurezza implementano.

Tipi:

// Target - cosa scansiona una capability
type Target struct {
    Type  TargetType        // domain, ip, port, url, cloud_resource
    Value string            // Il valore del target
    Meta  map[string]string // Contesto aggiuntivo
}

// Finding - cosa scopre una capability
type Finding struct {
    Type     FindingType    // asset, risk, attribute
    Severity Severity       // info, low, medium, high, critical
    Data     map[string]any // Payload flessibile
}

// Capability - l'interfaccia da implementare
type Capability interface {
    Name() string
    Run(ctx context.Context, target Target) ([]Finding, error)
}

Esempio di Implementazione:

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 - Formattazione dell'Output

Sistema di output multi-formato per il rendering dei risultati di scansione.

Formati Supportati:

  • Terminal (streaming, colorato tramite lipgloss)
  • JSON (bufferizzato, opzione pretty-print)
  • NDJSON (streaming, delimitato da newline)
  • Markdown (bufferizzato, report basati su template)
  • SARIF 2.1.0 (bufferizzato, integrazione GitHub/Azure)

Utilizzo Base:

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})

Conversione dei Finding delle Capability:

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-Output (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

Invio Concorrente (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 - Gate di Drift della Documentazione CLI

Percorre un albero di comandi cobra e genera, integra e verifica gli artefatti di documentazione costruiti da esso, così che la documentazione committata non possa silenziosamente divergere dal binario. Costruisci un Docs con clisurface.New, poi usa Docs.Write per rigenerare e Docs.CheckArtifacts più Docs.LintRepo per far fallire la CI quando i file committati, la prosa o i commenti Go non corrispondono più alla CLI. Vedi go doc ./pkg/clisurface per l'API completa.

Architettura

┌─────────────────────────────────────────────────────────────────────┐
│                     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             │
└─────────────────────────┘    └───────────────────────────────-──────┘

Estensione dei Tipi

Aggiungere un Nuovo Tipo di Target

  1. Apri una issue: "Serve il tipo di target git_repo per X"
  2. Uno sviluppatore backend revisiona la mappatura Tabularium
  3. Aggiungi a pkg/capability/target.go:
    TargetGitRepo TargetType = "git_repo"
    
  4. Aggiorna il metodo Valid()
  5. Aggiungi i test
  6. Aggiorna l'adapter Chariot

Aggiungere un Nuovo Tipo di Finding

  1. Apri una issue: "Serve il tipo di finding relationship per X"
  2. Definisci lo schema Data
  3. Aggiungi a pkg/capability/finding.go
  4. Aggiorna il converter in pkg/formatter/capability_converter.go
  5. Aggiungi i test

Moduli che Utilizzano Questo SDK

  • diocletian - Scanner di sicurezza cloud

Licenza

Apache License 2.0. Vedi LICENSE.

La licenza è dichiarata una sola volta, alla radice del repository. Non aggiungere intestazioni di copyright o licenza per singolo file — nemmeno quando si porta codice da un progetto affine che le contiene. Un LICENSE alla radice è la dichiarazione autorevole; ripeterlo su ogni file non è necessario.

Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    755
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    510
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    415
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    343
  • 5

    antifox

    antifox-ai/antifox

    Piattaforma multi-agente di penetration testing autonoma basata sull'IA che esegue ricognizione, scoperta della superficie d'attacco, validazione dello sfruttamento e consegna di report supportati da evidenze.

    259
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    258

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →