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
DLLHijackHunter — Scoperta, validazione e conferma automatizzata del DLL Hijacking. Trasformare le configurazioni errate locali in percorsi di attacco confermati e weaponizzati. | Kitploit
Strumenti/GitHubGitHub/ghostvectoracademy/dllhijackhunter
Escalation di PrivilegiScanner di VulnerabilitàGenerazione di PayloadMeccanismi di PersistenzaAnalisi Dinamica del Codice (DAST)ExploitMovimento LateralePenetration Testing
Condividi
Analisi di Binari
Apprendimento e Formazione
Red Teaming
GitHubghostvectoracademy/dllhijackhunter

DLLHijackHunter

Scoperta, validazione e conferma automatizzata del DLL Hijacking. Trasformare le configurazioni errate locali in percorsi di attacco confermati e weaponizzati.

Vedi Repository
396447113h 26m faRevisionato da Kitploit
<p align="center">
  <img src="https://img.shields.io/badge/Platform-Windows-blue?style=for-the-badge&amp;logo=windows" />
  <img src="https://img.shields.io/badge/.NET-8.0_%7C_10.0-purple?style=for-the-badge&amp;logo=dotnet" />
  <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" />
  <img src="https://img.shields.io/badge/Version-2.6.0-orange?style=for-the-badge" />
  <img src="https://img.shields.io/badge/Black%20Hat%20Arsenal-Europe%202026-CC0000?style=for-the-badge" />
  <img src="https://img.shields.io/badge/Black%20Hat%20Arsenal-SecTor%202026-CC0000?style=for-the-badge" />
</p>

<h1 align="center">DLLHijackHunter</h1>
<h4 align="center">Di <a href="https://projectmerai.com">ProjectMerai</a></h4>

<p align="center">
  <strong>Scoperta, validazione e conferma automatizzate del DLL hijacking su Windows</strong><br/>
  <em>Da "questa DLL potrebbe essere dirottabile" a "un utente standard può far caricare questa DLL a SYSTEM — eccone la prova."</em>
</p>

---

## Indice

- [Panoramica](#panoramica)
- [Avvio rapido](#avvio-rapido)
- [Come funziona](#come-funziona)
- [Cosa rileva](#cosa-rileva)
- [Ridurre i falsi positivi](#ridurre-i-falsi-positivi)
- [Verifica: sonda di caricamento e canary](#verifica-sonda-di-caricamento-e-canary)
- [Punteggio, livelli e catene di attacco](#punteggio-livelli-e-catene-di-attacco)
- [Riferimento all'utilizzo](#riferimento-allutilizzo)
- [Sicurezza e impatto operativo](#sicurezza-e-impatto-operativo)
- [Compilazione dal sorgente](#compilazione-dal-sorgente)
- [Laboratorio di test (HijackRange)](#laboratorio-di-test-hijackrange)
- [Limitazioni note](#limitazioni-note)
- [Confronto](#confronto)

---

## Panoramica

DLLHijackHunter individua le opportunità di DLL hijacking su un host Windows e si adopera per dimostrarle, non solo elencarle. Esso:

1. **Scopre** ogni punto in cui un binario viene avviato automaticamente — servizi, attività pianificate, chiavi Run, cartelle Startup, server COM, DLL AppInit/AppCert, voci IFEO e binari UAC ad auto-elevazione — e calcola dove verrebbe cercata ciascuna DLL importata.
2. **Filtra** le posizioni che un attaccante non può effettivamente sfruttare: API set, KnownDLL, directory in cui un utente standard non può scrivere, processi protetti e altro ancora.
3. **Verifica** (opzionale) con il vero loader di Windows, posizionando una DLL sonda benigna e controllando quale copia vince la ricerca.
4. **Conferma** (opzionale) distribuendo una DLL canary innocua, attivando il servizio/attività/oggetto COM e registrando l'identità con cui è effettivamente stato eseguito.
5. **Assegna un punteggio e riporta** ogni risultato in base a confidenza e impatto, e correla i risultati in catene di attacco (ad esempio *utente standard → SYSTEM*).

Ogni giudizio è formulato **dal punto di vista dell'attaccante** — un utente standard non privilegiato — indipendentemente dal fatto che lo scanner stesso venga eseguito con privilegi elevati. L'esecuzione come Amministratore offre allo strumento maggiore visibilità (ETW, canary, trigger dei servizi); non rende mai le directory protette scrivibili né gonfia il privilegio ottenuto.

---

## Avvio rapido

Scarica o compila `DLLHijackHunter.exe` (autonomo; non richiede l'installazione di .NET), quindi da un prompt **con privilegi elevati**:

```powershell
# Passive, read-only triage: no file drops, no service/task starts
.\DLLHijackHunter.exe --profile safe

# Full static analysis without touching the system, JSON report
.\DLLHijackHunter.exe --profile aggressive --no-canary --no-etw -o report.json

# Static analysis + real-loader verification (writes probe DLLs transiently)
.\DLLHijackHunter.exe --profile aggressive --no-canary --no-etw --verify-load -o report.html

# Everything, including ETW and canary confirmation — lab / authorised targets only
.\DLLHijackHunter.exe --profile aggressive -o report.html

# Focus on one application
.\DLLHijackHunter.exe --target "C:\Program Files\MyApp\app.exe" --no-canary
```

> **Antivirus:** le DLL canary e probe non sono firmate e si comportano come payload di hijack, quindi Microsoft Defender potrebbe metterle in quarantena. Lo strumento rileva questa situazione e riporta tali risultati come **inconclusivi** anziché "non hijackable". Su una macchina di test, escludere le directory di destinazione e `%ProgramData%\DLLHijackHunter` per ottenere risultati definitivi.

---

## Come funziona

```mermaid
flowchart TB
    subgraph S1["1 · Discovery"]
        direction LR
        EN["Launch points<br/>services · tasks · Run keys<br/>startup · COM · AutoElevate"] --> PE["PE analysis<br/>imports · delay loads<br/>manifest"] --> SO["Search order<br/>identity-aware PATH"]
        ETW["ETW runtime trace<br/>optional, elevated"]
    end
    subgraph S2["2 · Filter pipeline"]
        direction LR
        HG["Hard gates<br/>API sets · KnownDLLs<br/>writability"] --> SG["Soft gates<br/>manifest · privilege<br/>PPL · LoadLibraryEx"] --> DD["Dedup and<br/>profile filters"]
    end
    subgraph S3["3 · Verification (optional)"]
        direction LR
        LP["Load probe<br/>real Windows loader"] --> CN["Canary<br/>deploy, trigger, confirm"]
    end
    subgraph S4["4 · Output"]
        direction LR
        SC["Scoring and tiers"] --> AC["Attack chains"] --> RP["Console · JSON · HTML"]
    end
    S1 --> S2 --> S3 --> S4
```

| Fase | Richiede admin | Modifica il sistema |
|---|:---:|---|
| Scoperta statica + filtri | No (l'admin vede di più) | No |
| Scoperta runtime ETW | **Sì** | **Avvia** servizi ad avvio automatico (fino a 100) ed esegue attività pianificate (fino a 30) per provocare il caricamento di DLL |
| Sonda di caricamento (`--verify-load`) | No | Scrive brevemente una DLL sonda benigna in ogni posizione candidata, poi la rimuove e ripristina l'originale, se presente |
| Conferma canary | **Sì** | Scrive una DLL canary, arresta/avvia servizi, esegue attività, attiva oggetti COM, poi esegue la pulizia |

---

## Cosa rileva

### Tipi di hijack

| Tipo | Cosa significa | Note |
|---|---|---|
| **Phantom** | La DLL non esiste in nessun punto del percorso di ricerca | Collocala ovunque il binario effettui la ricerca |
| **Search order** | Una directory scrivibile viene cercata prima della copia legittima | Include la sovrascrittura di una DLL in una directory scrivibile |
| **ENV PATH** | Una directory scrivibile in `PATH` viene cercata per una DLL mancante | I servizi vengono valutati solo rispetto al PATH **macchina** — le voci PATH dell'utente non vengono mai cercate da un servizio |
| **Reindirizzamento .local** | Reindirizzamento `<app>.exe.local\<dll>` | Segnalato solo per eseguibili **senza manifest** (o quando IFEO `DevOverrideEnable=1`); il loader ignora `.local` in caso contrario, e non reindirizza mai le KnownDLLs |
| **Side-load (UAC)** | Copia un EXE ad auto-elevazione accanto a una DLL collocata | Solo per EXE con `<autoElevate>true</autoElevate>` nel loro manifest. L'auto-elevazione richiede una posizione attendibile, quindi la copia deve superare tale controllo (ad es. una cartella fittizia `C:\Windows \System32\`) |
| **AppInit DLLs** | `AppInit_DLLs` punta a una DLL scrivibile | Caricata in ogni processo che carica `user32.dll` |
| **AppCert DLLs** | `AppCertDLLs` punta a una DLL scrivibile | Caricata in ogni chiamante di `CreateProcess`/`WinExec` |

I binari IFEO `Debugger` e `SilentProcessExit\MonitorProcess` vengono enumerati e analizzati come qualsiasi altro punto di avvio. Gli hijack basati su CWD non vengono attualmente prodotti.

### Con quale identità viene eseguito il target

L'identità corretta determina sia il verdetto di escalation dei privilegi sia il punteggio di impatto:

- **Servizi** — `ObjectName` (LocalSystem, Local Service, Network Service o un account); i servizi svchost analizzano anche la loro `ServiceDll`.
- **Attività pianificate** — il principal dell'attività. Forme SID come `S-1-5-18` vengono mappate a `NT AUTHORITY\SYSTEM`; i principal di gruppo vengono eseguiti come il membro connesso (solo *Administrators + privilegi massimi* conta come elevato). Vengono analizzati anche i payload racchiusi in `rundll32`, `cmd /c` o `powershell -File`.
- **Chiavi Run / cartelle Startup** — enumerate per **ogni profilo utente caricato** (`HKEY_USERS`) e per la cartella Startup di ogni profilo, attribuite a quell'utente — non solo all'account che esegue lo scanner.
- **COM** — i server out-of-process seguono `AppID` → `RunAs` / `LocalService`; i server in-process vengono eseguiti con l'identità del client che li carica.

### Knowledge base e weaponisation del PATH

- Viene effettuato un confronto incrociato con uno snapshot incluso del dataset **[HijackLibs](https://hijacklibs.net/)** (≈590 DLL su ≈700 eseguibili, `Resources/hijacklibs.json`). Una corrispondenza aumenta la confidenza e collega il riferimento; nessuna corrispondenza non significa nulla. Aggiornalo sostituendo il file con `https://hijacklibs.net/api/hijacklibs.json`. Dataset © il progetto HijackLibs e i suoi contributori.
- Per ogni directory scrivibile nel PATH **macchina**, vengono generati candidati per noti servizi SYSTEM che sondano il PATH alla ricerca di DLL mancanti (`IKEEXT → wlbsctrl.dll`, `Spooler → ualapi.dll`, `Schedule → WptsExtensions.dll`, `SessionEnv → tsmsisrv.dll`, `WlanSvc → wlanhlp.dll`).

---

## Riduzione dei falsi positivi

**Gates rigidi** (il candidato viene scartato):

- **API set** — ogni nome di contratto `api-ms-*` / `ext-ms-*` viene risolto tramite lo schema degli API set, mai tramite l'ordine di ricerca.
- **KnownDLLs** — letti dalle directory di oggetti attive `\KnownDlls` e `\KnownDlls32` (non solo dall'elenco seed del registro), più `ntdll.dll`, che viene sempre mappato per primo.
- **Scrivibilità relativa all'attaccante** — una posizione conta solo se `Users`, `Authenticated Users`, `Everyone` o `INTERACTIVE` (più un account di servizio non privilegiato come `LOCAL SERVICE`) detiene il diritto che conta: **creare file** per un drop di DLL, **creare cartelle** per una directory `.local`. Questo viene calcolato dall'ACL, indipendentemente dal token dello scanner stesso, così una scansione elevata non vede mai `System32`, `Program Files` o la radice di un'unità (`C:\`) come scrivibili.

**Soft gate** (la confidenza viene adeguata, con la motivazione registrata nelle note del finding):

- **Binding Manifest / WinSxS** della DLL.
- **Delta di privilegio** — misurato rispetto a un **attaccante utente standard**: SYSTEM, LOCAL/NETWORK SERVICE e target elevati via UAC sono privilege escalation; i target con lo stesso privilegio vengono mantenuti come finding di persistenza / evasione delle difese.
- **Mitigazioni LoadLibraryEx** — import di `SetDefaultDllDirectories`, `AddDllDirectory`, `SetDllDirectory`.
- **Processi protetti** — binari PPL noti, servizi con `LaunchProtected` impostato nella configurazione SCM (copre le nuove versioni di Windows e i servizi AV/EDR di terze parti) e immagini `FORCE_INTEGRITY`.
- **Caricamenti opzionali con gestione degli errori.**

Se un gate non riesce a essere valutato, il candidato non viene penalizzato, ma il fallimento viene registrato nelle sue note e nel log anziché nascosto.

---

## Verifica: load probe e canary

### Load probe (`--verify-load`)

Per i candidati Phantom, Search-order e Side-load, una DLL di probe benigna viene copiata nella posizione scrivibile e un processo figlio di breve durata chiede al **vero loader di Windows** di risolvere il nome:

| Risultato | Significato | Effetto |
|---|---|---|
| **Wins** | Il loader ha scelto la posizione scrivibile | Ordine di ricerca dimostrato; il finding può raggiungere **High** |
| **LosesToProtected** | Ha vinto una copia KnownDLL, System32 o SxS | Probabile falso positivo; −40 di confidenza |
| **NotResolved** | Il nome non è stato risolto; l'errore del loader viene registrato | Inconcludente |
| **Error** | Il probe non è riuscito a essere eseguito — incluso il caso in cui il probe è stato **messo in quarantena dall'antivirus** | Inconcludente, nessuna penalità |
| **Skipped** | `.local`, PATH, AppInit/AppCert usano meccaniche diverse | — |

Il probe modella dove si trova realmente la posizione: una DLL nella **directory propria** del binario viene testata prima di System32 (come fa il loader); le altre posizioni usano l'ordine di ricerca classico o moderno a seconda dei casi. Viene eseguito come utente standard; ogni probe viene rimosso e qualsiasi file originale ripristinato.

### Conferma canary

```mermaid
sequenceDiagram
    autonumber
    participant H as DLLHijackHunter
    participant P as Hijack position
    participant T as Service / task / COM
    Note over H: Pick canary for target bitness,<br/>or build an export-forwarding proxy
    H->>P: Back up original DLL, write canary
    H->>T: sc start / schtasks /run / COM activation
    T->>P: Load DLL by name (search order)
    Note over P,T: Canary DllMain records user,<br/>integrity level and SeDebug
    T-->>H: Confirmation file written
    Note over H: Finding marked CONFIRMED
    H->>P: Remove canary, restore original DLL
    H->>T: Restore original service state
```

- **Nessun compilatore necessario.** I canary x64/x86 precompilati sono incorporati; quando la DLL dirottata ha export, un proxy di inoltro degli export viene sintetizzato a runtime tramite PE surgery affinché l'host continui a funzionare.
- **Auto-localizzante.** Il canary ricava il proprio percorso di conferma (`%ProgramData%\DLLHijackHunter\canary_<hash>.confirm`) dal proprio percorso di caricamento, così un singolo binario serve ogni candidato.
- **Nessun payload.** Registra solo chi lo ha caricato. Sorgente: `src/DLLHijackHunter/Resources/canary_src.c` (ricompilare con `Resources/build_canary.bat`, MSVC richiesto solo per questo).
- **Risultati:** `Fired`, `Timeout` (attivato, mai caricato), `Failed` (impossibile attivare/distribuire), `Blocked` (canary messo in quarantena dall'antivirus — inconcludente), `NotTested` (le chiavi Run, Startup, UAC bypass e i target manuali richiedono un logon/riavvio).
- **Avvertenza COM:** gli oggetti COM in-process vengono attivati da un client avviato dallo scanner, quindi un canary attivato prova il caricamento ma la sua identità è quella dello scanner — viene registrato come *contesto del chiamante* e non gonfia l'impatto.

I canary proxy possono comunque essere inconcludenti per export solo ordinali, nomi di export decorati o host che necessitano della DLL reale residente. Un canary inconcludente **non** significa che il dirottamento sia impossibile.

---

## Punteggio, livelli e catene di attacco

Ogni risultato riceve una **confidenza** (dai filtri, dalla sonda, dal canary e dalla knowledge base) e un punteggio di **impatto** (privilegio ottenuto, affidabilità dell'attivazione, stealth, persistenza al riavvio), combinati in un punteggio finale da 0 a 10.

| Livello | Requisito |
|---|---|
| **Confirmed** | Canary attivato |
| **High** | ≥ 80% **e** un segnale di prova: vittoria della sonda, osservazione ETW o corrispondenza HijackLibs |
| **Medium** | ≥ 50% (i risultati statici non verificati sono limitati a questo livello e contrassegnati come `Static-only`) |
| **Low** | ≥ 20% |
| **Informational** | Sotto il 20% ma sopra il `--min-confidence` del profilo |

Le **catene di attacco** correlano i risultati in narrazioni:

- **Direct Path (User → SYSTEM)** — qualsiasi risultato SYSTEM che un utente standard può sfruttare.
- **Ladder (User → Admin → SYSTEM)** — un UAC bypass silenzioso, mostrato solo quando non esiste un percorso diretto.
- **Long Con (Persistence)** — il miglior risultato di auto-avvio non di servizio (chiave Run, Startup, attività).

---

## Riferimento all'utilizzo

```text
-p, --profile <name>          aggressive | strict | safe | redteam | uac-bypass   [default: aggressive]
-o, --output <path>           Write a report; format from extension (.json / .html / .htm)
-f, --format <format>         console | json | html                              [default: console]
-t, --target <target>         Binary path, directory, or file name (partial match). Scopes discovery
                              and ETW to that target and skips system-wide PATH weaponisation.
    --min-confidence <0-100>  Override the profile's threshold (only when explicitly passed)
    --no-canary               Disable canary confirmation
    --no-etw                  Disable ETW runtime discovery (no service/task starts)
    --verify-load             Real-loader verification of search order (transient probe DLLs)
    --confirmed-only          Report only canary-confirmed findings
    --lpe-only                Ignore System32 / Program Files / Windows positions
    --canary-settle <sec>     Seconds to wait for a canary to fire after triggering
    --log-file <path>         Write a diagnostic log (enumeration, filter, and probe failures)
-v, --verbose                 Verbose console output
```

### Profili

| Profilo | Scopo | Canary | ETW | AutoElevate | COM | Risultati stesso privilegio | Risultati PPL | Confidenza minima |
|---|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
| **aggressive** | Audit completo, laboratori | ✅ | ✅ | ✅ | ✅ | mantenuti | mantenuti | 15% |
| **strict** | Solo escalation ad alta confidenza | ✅ | ✅ | — | — | scartati | scartati | 80% |
| **safe** | Produzione, sola lettura | — | — | — | — | mantenuti | scartati | 50% |
| **redteam** | Solo escalation confermata (implica `--confirmed-only`) | ✅ | ✅ | — | ✅ | scartati | scartati | 50% |
| **uac-bypass** | Vettori di auto-elevazione | — | — | ✅ | — | scartati | scartati | 20% |

### Output

- **Console** (predefinito): riepilogo, grafico dei livelli, risultati, catene di attacco. Nulla viene scritto su disco a meno che non si passi `--output` (un percorso non `.json`/`.html` riceve il report JSON quando ci sono risultati).
- **JSON / HTML**: risultati completi con note, risultati dei filtri, risultati di load-probe e canary, riferimenti alla knowledge-base e catene di attacco. Un report viene scritto anche quando non viene trovato nulla, quindi un file vuoto non significa mai un'esecuzione fallita.

### Codici di uscita

| Codice | Significato |
|---|---|
| `0` | Scansione completata (con o senza risultati) |
| `1` | Errore non gestito |
| `3` | `--confirmed-only` (o il profilo `redteam`) richiesto, ma il canary non può essere eseguito — non elevato, o canary disabilitato. Rifiutato invece di riportare un falso "0 risultati". |

---

## Sicurezza e impatto operativo

Usare DLLHijackHunter solo su sistemi di propria proprietà o per i quali si è esplicitamente autorizzati a effettuare valutazioni.

- `--profile safe` (o `--no-canary --no-etw`) è **in sola lettura** — adatto per il triage in produzione.
- **La modalità ETW avvia servizi ed esegue attività pianificate** per provocare caricamenti di DLL, anche senza il canary.
- **La modalità canary** sostituisce le DLL (con backup/ripristino), arresta e riavvia servizi, esegue attività e attiva oggetti COM. I servizi fragili possono comportarsi in modo anomalo mentre è caricato un canary proxy.
- **`--verify-load`** scrive DLL di probe in modo transitorio in posizioni scrivibili.
- Le DLL canary/probe non firmate possono essere messe in quarantena dall'antivirus; tali risultati vengono riportati come inconcludenti (`Blocked` / probe `Error`), mai come "non vulnerabile".

---

## Compilazione dai sorgenti

Requisiti: .NET 8 SDK (e .NET 10 SDK se si compila anche il target `net10.0-windows`). La compilazione su Linux/macOS funziona con `-p:EnableWindowsTargeting=true`.

```powershell
git clone https://github.com/projectmerai/DLLHijackHunter.git
cd DLLHijackHunter

# Self-contained single-file executable (no .NET runtime needed on the target)
dotnet publish src/DLLHijackHunter/DLLHijackHunter.csproj `
    -c Release -f net8.0-windows -r win-x64 --self-contained `
    -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true `
    -o ./publish
```

Il progetto supporta più target `net8.0-windows` e `net10.0-windows`, quindi `dotnet publish` richiede un `-f` esplicito.

---

## Laboratorio di test (HijackRange)

`HijackRange/` contiene un laboratorio deliberatamente vulnerabile per demo e test di regressione:

- **Alpha** — un servizio SYSTEM la cui directory del binario è scrivibile da `BUILTIN\Users`.
- **Beta** — un'attività pianificata SYSTEM con lo stesso schema.
- **Gamma** — una directory scrivibile aggiunta al PATH di sistema.

Compila con `HijackRange\build-all.bat`, distribuisci con `HijackRange\setup.ps1` (con privilegi elevati) e rimuovi con `HijackRange\teardown.ps1`. Vedi `HijackRange/demo-script.md`. Usa una VM usa e getta.

---

## Limitazioni note

- **L'ordine di ricerca statico è un'approssimazione.** Il comportamento a runtime (flag di `LoadLibraryEx`, `SetDefaultDllDirectories`, manifest) viene dedotto dagli import; usa `--verify-load` o il canary per la prova.
- **ETW** vede solo i processi e i caricamenti che avvengono durante la finestra di tracciamento (predefinita 120 s).
- **La persistenza** ("sopravvive al riavvio") è derivata dalla configurazione di avvio automatico, non da un test di riavvio.
- I risultati di **Run keys / Startup / side-load UAC** non possono essere confermati automaticamente tramite canary.
- **Le DLL canary e probe non sono firmate** e potrebbero essere bloccate dall'antivirus o dalle policy di controllo delle applicazioni.

---

## Confronto

| Capacità | **DLLHijackHunter** | Robber | DLLSpy | WinPEAS | Procmon |
|---|:---:|:---:|:---:|:---:|:---:|
| Scoperta automatizzata | ✅ | ✅ | ✅ | ✅ | ❌ |
| Rilevamento DLL fantasma | ✅ | ❌ | ✅ | ❌ | ✅ |
| Analisi dell'ordine di ricerca | ✅ | ❌ | ❌ | ❌ | ❌ |
| Verifica ACL relativa all'attaccante | ✅ | Parziale | ❌ | Base | ❌ |
| Monitoraggio runtime ETW | ✅ | ❌ | ❌ | ❌ | ✅ |
| Verifica con loader reale | ✅ | ❌ | ❌ | ❌ | ❌ |
| Prova di esecuzione canary | ✅ | ❌ | ❌ | ❌ | ❌ |
| Analisi di escalation dei privilegi | ✅ | ❌ | ❌ | ❌ | ❌ |
| Scoperta di bypass UAC | ✅ | ❌ | ❌ | ❌ | ❌ |
| Generazione di DLL proxy a runtime | ✅ | ❌ | ❌ | ❌ | ❌ |
| Punteggio di confidenza e catene di attacco | ✅ | ❌ | ❌ | ❌ | ❌ |
| Correlazione con HijackLibs | ✅ | ❌ | ❌ | ❌ | ❌ |
| Report HTML / JSON | ✅ | ❌ | ❌ | TXT | ❌ |
| Binario autonomo | ✅ | ❌ | ❌ | ✅ | ❌ |

---

## Licenza

MIT

## Crediti

Realizzato da **[ProjectMerai](https://projectmerai.com)**. Dati della knowledge-base dal progetto [HijackLibs](https://hijacklibs.net/).
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.

    546
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

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

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

    324
  • 5

    estorides

    grisuno/estorides

    Aggrega in parallelo oltre 99 fonti OSINT gratuite, risolve le entità in un knowledge graph ed esporta in STIX 2.1, MISP o GraphML con analisi assistita da LLM.

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

    252

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →