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
Package-Inferno — Uno scanner di pacchetti pubblico per la comunità | Kitploit
Strumenti/GitHubGitHub/mhaggis/package-inferno
Analisi StaticaScanner di VulnerabilitàSicurezza dei ContenitoriAnalisi MalwareSicurezza CloudDevSecOpsRilevamento SegretiThreat IntelligenceSicurezza della Supply Chain
GitHubmhaggis/package-inferno

Package-Inferno

1333210 mesi faNon ancora revisionato

Uno scanner di pacchetti pubblico per la comunità

Vedi Repository
Condividi

PackageInferno

Logo di PackageInferno

Scanner della supply chain npm incredibilmente semplice, Docker‑first. Un solo file compose esegue:

  • Enumerator → crea la coda dei pacchetti
  • Fetcher → scarica i tarball (e li carica opzionalmente su S3)
  • Analyzer → analisi statica + YARA opzionale
  • Postgres → DB locale per i risultati
  • Streamlit Dashboard → visualizza i risultati su http://localhost:8501

Questa è l'edizione solo contenitori. Il progetto può essere realizzato per scalare utilizzando EC2, SQS e RDS. La maggior parte è già predisposta nel toolset.


Cosa ottieni

  • Pipeline end‑to‑end in Docker (nessuna installazione sull'host oltre a Docker)
  • Regole configurabili tramite scan.yml (allowlist, soglie, YARA)
  • Schema Postgres locale + cronologia delle scansioni (scan_runs) pronto all'uso
  • Upload S3 opzionali per tarball e risultati (credenziali tramite ~/.aws)
  • Dashboard Streamlit: ricerca, drill‑down e analisi

Contenuti

  • docker-compose.yml – servizi: db, enumerator, fetcher, analyzer, dashboard, init-db
  • enumerator/ – worker Node che crea la coda NDJSON
  • fetcher/ – worker Node che scarica i tarball (+ caricamento su S3 se abilitato)
  • analyzer/ – analizzatore statico Python (+ YARA inline opzionale)
  • dashboard/ – app Streamlit (porta 8501)
  • infra/migrations.sql – schema DB core (packages, versions, findings, scores, indexes)
  • infra/20251106_scan_runs.sql – tabella della cronologia delle scansioni
  • scan.yml – configurazione dell'analisi (regole, punteggi, allowlist, YARA)
  • scripts/run_pipeline.sh – esegui enumerate → fetch → analyze
  • scripts/init_db.sh – bootstrap dello schema DB
  • scripts/test_setup.sh – validazione automatica dell'installazione
  • SCANNING_GUIDE.md – strategie di scansione dettagliate ed esempi

Avvio rapido (locale)

Prerequisiti: Docker Desktop (o engine) con Compose v2.

Installazione con una riga

curl -fsSL https://raw.githubusercontent.com/MHaggis/Package-Inferno/main/install.sh | bash

Questo clona il repo in ~/package-inferno e ti fornisce le istruzioni per iniziare.

Opzione A: usa le immagini precompilate (la più veloce)

Scarica ed esegui i contenitori precompilati da GitHub Container Registry:

# Clone the repo (for config files and scripts)
git clone https://github.com/MHaggis/Package-Inferno.git
cd Package-Inferno

# Run with pre-built images
docker compose -f docker-compose.ghcr.yml up -d db
./scripts/init_db.sh
SEEDS="lodash,express" docker compose -f docker-compose.ghcr.yml run --rm enumerator
docker compose -f docker-compose.ghcr.yml run --rm fetcher
docker compose -f docker-compose.ghcr.yml run --rm analyzer

Immagini disponibili:

  • ghcr.io/mhaggis/package-inferno/enumerator:main
  • ghcr.io/mhaggis/package-inferno/fetcher:main
  • ghcr.io/mhaggis/package-inferno/analyzer:main

Opzione B: build dal sorgente

Validazione automatica dell'installazione

Esegui lo script di test per validare la tua installazione:

./scripts/test_setup.sh

Questo script:

  • ✓ Verifica Docker e Docker Compose
  • ✓ Avvia e inizializza il database
  • ✓ Esegue una scansione di test (2 pacchetti)
  • ✓ Verifica che i risultati siano memorizzati correttamente

Configurazione manuale

  1. Avvia Postgres e inizializza lo schema:
docker compose up -d db
./scripts/init_db.sh
  1. Esegui la pipeline:
./scripts/run_pipeline.sh
  1. Avvia la dashboard:
docker compose up -d dashboard
# open http://localhost:8501

I risultati finiscono in ./out/findings/*.findings.json e nella tabella findings quando il DB è abilitato.


Modalità di scansione

PackageInferno supporta diverse strategie di scansione in base ai tuoi obiettivi:

ModalitàCaso d'usoVelocitàCoperturaComando
Seeds specificiTest/indagine su pacchetti notiMassimaMirataSEEDS="pkg1,pkg2"
Piccolo lottoValidazione del setup, scansione campioneAlta10-100 pkgMAX_CHUNKS=2 CHUNK_LIMIT=10
Registry completoAudit completo della supply chainOre-Giorni2M+ pkgMAX_CHUNKS=0 CHUNK_LIMIT=100
Changes FeedMonitora le nuove release (incluso automaticamente)In tempo realeAggiornamenti recentiIntegrato

1. Scansione di pacchetti specifici (consigliata per i test)

Seleziona i pacchetti specifici che vuoi analizzare:

# Single command with seeds
export SEEDS="lodash,express,axios"
./scripts/run_pipeline.sh

# Or from a file
echo -e "react\nvue\nangular" > packages.txt
export SEEDS_FILE=packages.txt
./scripts/run_pipeline.sh

Come ho testato inizialmente: ho usato SEEDS="is-odd,is-even" per una validazione rapida.

2. Scansione dal registry npm (_all_docs)

Scansiona i pacchetti paginando il registry di npm:

# Clean previous runs
rm -rf downloads/* out/*

# Scan 2 pages of 10 packages each (20 packages)
export MAX_CHUNKS=2        # Number of pages
export CHUNK_LIMIT=10      # Packages per page
unset SEEDS                # Important: disable seeds mode

# Run individual steps for better visibility
docker compose run --rm enumerator  # Discovers and queues
docker compose run --rm fetcher     # Downloads tarballs
docker compose run --rm analyzer    # Scans for threats

Esempio di output:

config: chunkLimit=10, maxChunks=2
checking recent changes feed...
changes feed: enqueued 2 new versions
enumerating via _all_docs (fresh scan)
page 1/2 count: 10
page 2/2 count: 10
done, enqueued 22 (22 new versions)

3. Monitoraggio continuo (scansione illimitata)

Scansiona l'intero registry npm:

export MAX_CHUNKS=0        # 0 = unbounded
export CHUNK_LIMIT=100     # Larger batches for efficiency
./scripts/run_pipeline.sh

Avviso: questa operazione richiederà ore/giorni e scansionerà centinaia di migliaia di pacchetti. Monitora lo spazio su disco e la dimensione del database.

4. Riprendi le scansioni interrotte

L'enumerator salva lo stato in ./out/enumerator_state.json con la posizione del cursore:

{
  "last_seq": "0",
  "last_startkey": "package-name",
  "last_run": "2025-11-23T19:24:49.123Z",
  "last_processed": 22,
  "last_new": 22
}

È sufficiente eseguire di nuovo la pipeline e riprenderà dall'ultimo cursore:

./scripts/run_pipeline.sh  # Automatically resumes

Per forzare una nuova scansione:

rm -f out/enumerator_state.json
./scripts/run_pipeline.sh

Esempi di risultati di scansione

Da una scansione di 2 pagine di 22 pacchetti, ecco cosa ha rilevato PackageInferno:

-- Top suspicious packages by score
SELECT p.name, s.score, s.label, COUNT(f.id) as findings 
FROM packages p 
JOIN versions v ON p.id = v.package_id 
JOIN scores s ON v.id = s.version_id 
LEFT JOIN findings f ON v.id = f.version_id 
GROUP BY p.name, s.score, s.label 
ORDER BY s.score DESC;

-- Results:
   name                | score | label      | findings
-----------------------+-------+------------+----------
 rendition             | 606   | malicious  | 153
 vs-deploy             | 454   | malicious  | 119
 --123hoodmane-pyodide | 213   | malicious  | 46

Cosa rendeva rendition così sospetto?

  • 57 × url_outside_allowlist – domini non in allowlist
  • 46 × suspicious_pattern – pattern shell/eval
  • 12 × advanced_obfuscation – codifica hex, XOR, array di stringhe
  • 6 × big_base64_blob – payload codificati di grandi dimensioni
  • 18 × url_in_code – URL incorporati

Il sistema di punteggio (configurato in scan.yml) aggrega questi risultati per produrre un punteggio di rischio e un'etichetta (clean, suspicious o malicious).


Esplorare i risultati

Tramite la dashboard (consigliato)

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.

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    536
  • 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à.

    424
  • 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.

    355
  • 5

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    294
  • 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.

    276

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →