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
iLEAPP — Analizza le estrazioni forensi di iOS e iPadOS in report HTML, TSV, timeline, KML e LAVA con scoperta modulare degli artefatti e supporto per i backup iTunes crittografati. | Kitploit
Strumenti/GitHubGitHub/abrignoni/ileapp
Sicurezza iOSInformatica ForenseMobile ForensicsDigital ForensicsRisposta agli IncidentiAnalisi dei LogTop in Mobile Forensics n.4
GitHubabrignoni/ileapp

iLEAPP

Analizza le estrazioni forensi di iOS e iPadOS in report HTML, TSV, timeline, KML e LAVA con scoperta modulare degli artefatti e supporto per i backup iTunes crittografati.

1.5k3271218h 28m faRevisionato da Kitploit
Condividi
Vedi Repository
![iLEAPP](https://assets.kitploit.com/production/public/readmes/50809/7cf8d283b026e5504e0e004470f967b43965a945c50865a8696035d46509f362/993372e8a218256a24504b4c2663aa21e83c5c446a7b54466ca980e86df2db65-display-v1.webp)

# Parser di log, eventi e plist di iOS

iLEAPP analizza le estrazioni forensi di iOS e iPadOS e produce output in HTML, TSV, timeline, KML e LAVA. Supporta iOS/iPadOS dalla versione 11 fino alle versioni attuali.

Consulta l'elenco completo e ricercabile degli artefatti su [leapps.org/artifacts](https://leapps.org/artifacts) (filtra per strumento LEAPP).

## Avvio rapido (consigliato)

Scarica una release precompilata — non è richiesta l'installazione di Python.

- [LEAPPs Releases](https://leapps.org/releases) — sfoglia tutti gli strumenti della famiglia LEAPP
- [iLEAPP GitHub Releases](https://github.com/abrignoni/iLEAPP/releases) — download diretti

| Piattaforma | Download |
| -------- | -------- |
| Windows (Intel/AMD) | `iLEAPP-*-windows-x64-portable.zip` |
| Windows (ARM) | `iLEAPP-*-windows-arm64-portable.zip` |
| macOS (Apple Silicon) | `iLEAPP-*-macos-arm64.dmg` |
| macOS (Intel) | `iLEAPP-*-macos-x64.dmg` |
| Linux (Intel/AMD) | `iLEAPP-*-linux-x64.AppImage` |
| Linux (ARM) | `iLEAPP-*-linux-arm64.AppImage` |

Ogni download contiene un solo programma, `ileapp`. Il file `SHA256SUMS.txt` presente in ogni release consente di verificare un download.

**Compatibilità Linux:** le AppImage ufficiali sono compilate su Ubuntu 22.04 e richiedono glibc 2.35 o
successiva.

**GUI** — apri iLEAPP nel modo consueto: facendo doppio clic su `ileapp.exe` dallo zip su
Windows, su iLEAPP in Applicazioni su macOS, oppure sull'AppImage su Linux. Avviato senza argomenti, apre la finestra; seleziona il tipo di input,
il percorso della sorgente, la cartella di output e i moduli da elaborare.

**CLI** — passa gli argomenti a `ileapp` in un terminale e verrà eseguito come riga di comando. La
cartella di output deve esistere già. Su Windows, usa `ileapp.exe` dallo zip.

```
ileapp.exe -t zip -i C:\path\to\extraction.zip -o C:\path\to\output\
```

Su Linux, esegui l'AppImage con gli stessi argomenti. Su macOS si trova all'interno dell'app; per
digitare semplicemente `ileapp` in un terminale, collegalo al tuo PATH una volta:

```
sudo ln -s /Applications/iLEAPP.app/Contents/MacOS/ileapp /usr/local/bin/ileapp
```

## Tipi di input

| Tipo | Descrizione |
| ---- | ----------- |
| `fs` | Cartella di file estratti con percorsi e nomi normali |
| `zip` | Archivio ZIP contenente file con nomi normali |
| `tar` | Archivio TAR, semplice o compresso con xz (`.tar.xz`) |
| `gz` | Archivio compresso con GZIP |
| `itunes` | Cartella di backup iTunes/Finder con percorsi e nomi con hash |
| `file` | Input di un singolo file |

I backup iTunes/Finder crittografati (`-t itunes`) sono supportati. La GUI richiederà una password prima dell'elaborazione quando viene rilevata la crittografia. Da CLI, passare la password con `--itunes_password` (vedere [Opzioni di parsing facoltative](#optional-parsing-options) di seguito).

## Argomenti CLI

Queste opzioni si applicano solo alla **CLI** (`ileapp` / `ileapp.exe` con argomenti, oppure `python ileapp.py`). La GUI (`ileapp` avviato senza argomenti, oppure `python ileappGUI.py`) espone le stesse impostazioni tramite la propria interfaccia anziché con flag da riga di comando.

Eseguire `ileapp --help` (oppure `python ileapp.py --help` dai sorgenti) per il riferimento integrato.

### Parsing di un caso

Questi tre argomenti sono obbligatori per una normale esecuzione di parsing:

| Argomento | Forma lunga | Descrizione |
| -------- | --------- | ----------- |
| `-t` | | Tipo di input: `fs`, `tar`, `zip`, `gz`, `itunes` o `file` |
| `-i` | `--input_path` | Percorso del file o della cartella di input |
| `-o` | `--output_path` | Percorso della cartella di output (**deve già esistere**) |

**Esempio:**

```
ileapp -t zip -i /path/to/extraction.zip -o /path/to/output/
```

### Opzioni di parsing facoltative

| Argomento | Forma estesa | Descrizione |
| -------- | --------- | ----------- |
| `-w` | `--wrap_text` | Passa questo flag per **disabilitare** il ritorno a capo del testo nei file di output |
| `-m` | `--load_profile` | Percorso di un file di profilo iLEAPP (`.ilprofile`) per limitare i moduli eseguiti |
| `-d` | `--load_case_data` | Percorso di un file di dati di caso LEAPP (`.lcasedata`) |
| `--custom_output_folder` | | Nome personalizzato per la sottocartella di output del report |
| `--custom_artifacts_path` | | Cartella aggiuntiva da cui caricare i moduli degli artefatti (ad es. `scripts/alternate_artifacts`) |
| `--html_row_limit` | | Numero di righe oltre il quale la tabella di un artefatto viene omessa dalla sua pagina HTML, che punta invece al database LAVA e all'esportazione TSV. Predefinito 50000; `0` scrive tutte le tabelle. La GUI usa il valore predefinito |
| `--itunes_password` | | | Password per un backup iTunes/Finder crittografato (`-t 12345`) |

### Modalità di utilità standalone

Queste modalità non eseguono il parsing di un caso. Usale **da sole** — senza `-t`, `-i` o `-o`:

| Argomento | Forma estesa | Descrizione |
| -------- | --------- | ----------- |
| `-p` | `--artifact_paths` | Scrive tutti i percorsi di ricerca degli artefatti in `path_list.txt` nella directory corrente |
| `-c` | `--create_profile_casedata` | Procedura guidata interattiva per creare un file `.ilprofile` o `.lcasedata` nella cartella specificata |

**Esempi:**

```
ileapp -p
ileapp -c /path/to/output/folder/
```

## Contribuire

I moduli degli artefatti risiedono in `scripts/artifacts/` e vengono caricati dinamicamente a runtime.

**Nuovi moduli:** inizia con la guida passo passo su [How to Write an iLEAPP Module](https://leapps.org/blog-post?post=2026-06-14-how-to-write-an-ileapp-module).

**Riferimenti aggiuntivi:**

- [Artifact Info Block Structure](https://github.com/abrignoni/ileapp/blob/main/admin/docs/artifact_info_block.md)
- [Helper Functions for Artifact Modules](https://github.com/abrignoni/ileapp/blob/main/admin/docs/helper_functions.md)
- [Updating Modules for Automatic Output Generation](https://github.com/abrignoni/ileapp/blob/main/admin/docs/module_updates.md)
- [Updating Complex Modules to Include LAVA Output](https://github.com/abrignoni/ileapp/blob/main/admin/docs/module_updates_advanced.md)
- [Testing Modules](https://github.com/abrignoni/ileapp/blob/main/admin/docs/testing/readme.md)

## Dati di test e sample_data per la tua PR

Una PR che aggiunge o modifica un artefatto è più facile da revisionare e unire quando arriva con
due cose: un piccolo fixture di test ricavato da un'estrazione reale, e valori `sample_data` che
registrano ciò che il modulo ha prodotto. Gli script generano entrambi. Ecco l'intero flusso.

Una regola prima di tutto: qualunque cosa tu faccia il commit qui diventa pubblica. Usa solo dati che
sei autorizzato a condividere, come un dispositivo di test che hai popolato tu stesso, un'immagine di ricerca pubblica,
o un file che hai sanitizzato manualmente. Mai materiale di casi reali.

**1. Ricava un fixture dalla tua estrazione**

```
python admin/test/scripts/make_test_data.py <module> --case 1 --input <extraction.zip>
```

Questo estrae i file che i pattern `paths` del tuo modulo corrispondono dall'estrazione e scrive
il file di caso `admin/test/cases/testdata.<module>.json` più un piccolo zip per artefatto
sotto `admin/test/cases/data/<module>/`.

Regole sulle dimensioni: sotto i 10 MB per zip, eseguine il commit con la PR. Tra 10 e 25 MB, esegui il commit del
file di caso e allega lo zip a un commento della PR. Più grande di così, segnalalo nella PR e un
maintainer organizzerà un passaggio di consegne.

**2. Registra l'output atteso**

```
TZ=UTC python admin/test/scripts/test_module.py <module> -a all -c all
```

Questo esegue il modulo contro il fixture e scrive uno snapshot dell'output in
`admin/test/results/<module>/`. Esegui il commit anche dello snapshot. Diventa la baseline che
protegge il modulo dopo il merge. Mantieni la parte `TZ=UTC`: gli snapshot committati sono in UTC
e la CI viene eseguita in UTC.

**3. Esegui lo stesso confronto che eseguirà la CI**

```
python admin/test/scripts/run_test_cases.py --module <module>
```

**4. Genera i valori di sample_data**

```
python admin/scripts/validate_sample_data.py --emit <extraction.zip> --key <image_name>
```

Questo esegue iLEAPP end-to-end sulla tua estrazione e stampa blocchi `sample_data` pronti da incollare per i moduli modificati sul tuo branch. Incollali nel `__artifacts_v2__` del tuo modulo e aggiungi il nome e la versione dell'app che hai visto sull'immagine. Se un conteggio è zero, verifica che il file sorgente sia davvero vuoto prima di registrarlo.

**5. Esegui il commit di tutto e apri la PR**

Esegui il commit del modulo, del file case, degli zip fixture e dello snapshot registrato insieme.
Maggiori dettagli sono disponibili in
[admin/docs/testing/create_module_test_cases.md](https://github.com/abrignoni/ileapp/blob/main/admin/docs/testing/create_module_test_cases.md).

Se la tua estrazione non può essere condivisa, apri comunque la PR e segnalalo. Spesso una fixture può essere
ricavata invece da un'immagine di ricerca pubblica, oppure il file reale può essere sanitizzato manualmente. La
revisione non si ferma mentre risolviamo questo punto.

## Esecuzione dal sorgente

Le release sono il modo più semplice per eseguire iLEAPP. Usa il sorgente se stai sviluppando moduli o hai bisogno di modifiche non ancora rilasciate da `main`.

### Requisiti

- Python 3.11 a 3.15
- Git

### Configurazione

```
git clone https://github.com/abrignoni/iLEAPP.git
cd iLEAPP
python3 -m venv venv
source venv/bin/activate          # Windows: venv\Scripts\activate
pip install -r requirements.txt
```

Su **Linux**, installa `tkinter` per la GUI:

```
sudo apt-get install python3-tk
```

Guida alla configurazione su Windows da Hexordia:

- [ILEAPP Walkthrough (PDF)](https://www.hexordia.com/s/ILEAPP-Walkthrough.pdf)
- [ILEAPP Walkthrough (video)](https://www.youtube.com/watch?v=7qvVFfBM2NU)

### Utilizzo

La cartella di output deve esistere prima dell'esecuzione. Le build dai sorgenti riportano una versione `-dev` (ad es. `2.6.0-dev.0`) per distinguerle dalle build di rilascio ufficiali.

**CLI:**

```
python ileapp.py -t zip -i /path/to/extraction.zip -o /path/to/output/
python ileapp.py -t raw -i /path/to/acquisition.E01 -o /path/to/output/
```

`raw` legge un'immagine disco (`.img`, `.dd`, `.bin`, o qualsiasi segmento numerato `.001` di
un set diviso), oppure un'acquisizione e i segmenti o i file accanto ad essa (EnCase/EWF
`.E01`, SMART `.s01`, EWF2 `.Ex01`, AFF `.aff`, AFM `.afm`, qualsiasi `.aff` in una cartella AFD,
AFF4 `.aff4`, un `.dmg` Apple, con qualsiasi file `.dmgpart` accanto ad esso, `.sparseimage` o
cartella `.sparsebundle`, oppure un disco di macchina virtuale, `.vhd`, `.vhdx`, `.vmdk` o `.qcow2`), in
loco: senza montaggio e senza diritti di amministratore. I suoi volumi NTFS, FAT32, FAT16, FAT12, exFAT, ext2/3/4,
F2FS, HFS+, APFS, QNX6, QNX4, ETFS, EFS, SquashFS, JFFS2, UBI/UBIFS, YAFFS e QNX IFS
vengono cercati direttamente (e un ambiente U-Boot o un archivio Belkin NVRM viene letto come un unico
file), e
solo i file richiesti da un artefatto vengono estratti dall'immagine. Le prove logiche, un
EnCase `.L01` o un FTK Imager `.ad1`, vengono lette come i file che contengono. La GUI seleziona
`raw` autonomamente per quelle estensioni, e per una cartella sparse bundle o AFD scelta con
il suo pulsante cartella. Vedi `admin/docs/raw_image_input.md`.

Un'immagine cifrata si apre con la sua password (`--image_password_file` o
`--image_password_env`), oppure, quando è sigillata a un certificato, con la chiave privata
RSA di quel certificato (`--image_private_key`). Un volume BitLocker in un'immagine si apre con la sua
password o recovery password, fornite allo stesso modo, oppure con la sua startup key
(`--bitlocker_key`, ripetibile), un volume APFS cifrato da macOS via software con la sua
password o personal recovery key, e un container LUKS con la sua passphrase, ciascuno fornito
allo stesso modo. Al terminale viene richiesto ciò che manca, e la GUI lo chiede tramite dialoghi;
un volume BitLocker, APFS o LUKS che nulla riesce ad aprire viene segnalato e non analizzato.

Le immagini disco di un set RAID software Linux (md, o LVM2 su più dischi) vengono lette
insieme: forniscile tutte a `-i` con `-t raw`, oppure selezionale insieme nella finestra di dialogo
file della GUI. Data un'immagine che contiene un membro, gli altri membri vengono cercati nella sua
cartella in base a ciò che ciascun file registra su se stesso, non in base al suo nome; la riga di comando elenca
ciò che ha trovato e ciò che ha escluso e perché prima di leggere il set (`--no-find-members`
legge solo l'immagine fornita), e la GUI chiede prima di leggere i file che ha trovato. Il report
nomina ogni immagine letta e contrassegna quelle trovate automaticamente. Un'immagine che contiene un
membro md viene letta anche con i suoi array: un membro RAID1 isolato con metadati 1.1 o 1.2
ora legge il suo filesystem attraverso l'array, e i nomi dei suoi volumi acquisiscono il nome dell'immagine o
dell'array come prefisso. Un disco fornito due volte viene letto una sola volta. Un'immagine in cui non viene trovato
alcun metadato RAID viene letta come prima; vedi `admin/docs/raw_image_input.md` per ciò che
qnxprobe 1.71 fa con immagini DDF, IMSM e membri md lette da sole.

`tar` legge anche un tar compresso con xz (`.tar.xz`), e la GUI seleziona `tar` per quella
estensione. Un tar compresso, incluso `.tar.gz`, viene decompresso una volta nella cartella del report
prima che qualsiasi file venga letto, quindi l'esecuzione necessita di spazio libero lì per il tar non compresso. La
copia viene eliminata al termine dell'esecuzione, e il log dell'esecuzione indica quanto tempo ha richiesto il passaggio.

**GUI:**

```
python ileappGUI.py
```

Vedi [Argomenti CLI](#cli-arguments) sopra, oppure esegui `python ileapp.py --help`.

### Compilazione dei binari

`packaging/build.py` compila `ileapp` con PyInstaller per la macchina su cui viene eseguito, dallo
stesso ambiente virtuale. Esegui prima `python admin/scripts/fetch_unifiedlog_iterator.py` per
includere il parser Unified Log.

```
python packaging/build.py exe          # dist/iLEAPP/, and dist/iLEAPP.app on macOS
python packaging/build.py smoke        # run what it built, without opening a window
python packaging/build.py installer    # Windows: Inno Setup installer; macOS: .dmg; Linux: AppImage
```

`exe --onefile` crea invece `dist/ileapp` (`dist\ileapp.exe` su Windows) come singolo file. L'installer per Windows richiede [Inno Setup](https://jrsoftware.org/isdl.php); su Linux, `smoke` richiede un display, che `xvfb-run` fornisce. `python packaging/build.py --help` mostra il resto.

Una build Linux richiede la glibc della macchina che l'ha creata, o una versione più recente. Una build creata su una distribuzione più recente non si avvierà su quelle più vecchie; compila su Ubuntu 22.04 per allinearti alle build di rilascio.

## Politica di firma del codice

Firma del codice gratuita fornita da [SignPath.io](https://about.signpath.io/), certificato di [SignPath Foundation](https://signpath.org/).

Le build per Windows non sono ancora firmate. iLEAPP sta facendo domanda al programma di firma del codice gratuito per progetti open source di SignPath Foundation, e questa politica si applica a ogni rilascio Windows firmato nell'ambito di tale programma.

Gli eseguibili Windows allegati alle
[GitHub Releases](https://github.com/abrignoni/iLEAPP/releases) sono compilati da questo
repository tramite GitHub Actions, su runner ospitati da GitHub
([`release.yml`](https://github.com/abrignoni/ileapp/blob/main/.github/workflows/release.yml)). In base a questa politica, SignPath firma solo
ciò che è stato compilato da quel workflow. Le immagini disco macOS sono firmate separatamente, con un Apple
Developer ID, e notarizzate da Apple.

SignPath firma `ileapp.exe`, il programma in singolo file nello zip portatile. I file di terze parti
inclusi al suo interno, come il parser Unified Log di Mandiant (`unifiedlog_iterator.exe`), non sono
firmati singolarmente.

### Ruoli del team

- Committer e revisori: [@abrignoni](https://github.com/abrignoni),
  [@JamesHabben](https://github.com/JamesHabben),
  [@Johann-PLW](https://github.com/Johann-PLW), [@stark4n6](https://github.com/stark4n6)
- Approvatori: [@abrignoni](https://github.com/abrignoni),
  [@Johann-PLW](https://github.com/Johann-PLW)

Le modifiche proposte da persone che non sono committer vengono revisionate da un committer prima di essere
unite. Ogni richiesta di firma di un rilascio viene approvata da un approvatore.

### Informativa sulla privacy

iLEAPP elabora le estrazioni localmente, sulla macchina su cui viene eseguito. Questo programma non
trasferisce alcuna informazione ad altri sistemi in rete se non espressamente richiesto dall'
utente o dalla persona che lo installa o lo utilizza.

La stessa politica vale per gli altri LEAPP:
[leapps.org/releases#code-signing-policy](https://leapps.org/releases#code-signing-policy).

## Licenza

Il codice di iLEAPP è sotto licenza MIT (`LICENSE`). Per mostrare le immagini HEIC, i programmi pacchettizzati nella
pagina delle release includono heicreader, che è MIT ed è compilato da codice MIT e BSD-3-Clause. I testi
delle sue licenze sono in [`LICENSES/`](https://github.com/abrignoni/ileapp/blob/main/LICENSES/THIRD-PARTY-NOTICES.md). Ogni programma pacchettizzato riporta inoltre,
in `LICENSES/bundled/`, la licenza di ciascun pacchetto Python che contiene e di ciascuna libreria che preleva dalla macchina di build, e indica quelle
sotto termini copyleft, come simplekml (LGPL), con un link al loro codice sorgente.

## Ringraziamenti

Questo strumento di triage è il risultato di uno sforzo collaborativo di molte persone nella comunità DFIR.

Logo di iLEAPP per gentile concessione di Kevin Pagano. Il precedente logo di iLEAPP era di Derek Eiri.
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.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    647
  • 3

    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.

    421
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    389
  • 5

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

    333
  • 6

    SafeLine

    chaitin/safeline

    WAF self-hosted e reverse proxy che filtra il traffico HTTP malevolo, blocca SQL injection, XSS e attacchi bot, con limitazione del tasso e crittografia dinamica HTML/JS.

    331

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →