diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md index a27694aff..9c7a3a926 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md @@ -1,8 +1,8 @@ -# Malware Analysis +# Analisi del malware {{#include ../../banners/hacktricks-training.md}} -## Forensics CheatSheets +## Schede di riferimento Forensics [https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/) @@ -18,7 +18,7 @@ ### Yara -#### Installazione +#### Install ```bash sudo apt-get install -y yara ``` @@ -36,9 +36,9 @@ python malware_yara_rules.py yara -w malware_rules.yar image #Scan 1 file yara -w malware_rules.yar folder #Scan the whole folder ``` -#### YaraGen: Controllare malware e creare regole +#### YaraGen: Controlla la presenza di malware e crea regole -Puoi usare lo strumento [**YaraGen**](https://github.com/Neo23x0/yarGen) per generare regole yara da un binario. Consulta questi tutorial: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) +Puoi usare lo strumento [**YaraGen**](https://github.com/Neo23x0/yarGen) per generare yara rules da un binary. Consulta questi tutorial: [**Part 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Part 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Part 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/) ```bash python3 yarGen.py --update python3.exe yarGen.py --excludegood -m ../../mals/ @@ -57,26 +57,26 @@ clamscan folderpath #Scan the whole folder ``` ### [Capa](https://github.com/mandiant/capa) -**Capa** rileva potenzialmente **malicious capabilities** in eseguibili: PE, ELF, .NET. Quindi troverà cose come Att\&ck tactics, o capabilities sospette come: +**Capa** rileva potenzialmente **capacità** dannose negli eseguibili: PE, ELF, .NET. Quindi troverà cose come Att\&ck tactics, o capacità sospette come: -- check for OutputDebugString error -- run as a service -- create process +- controllare l'errore OutputDebugString +- eseguire come servizio +- creare un processo -Scaricalo nel [**Github repo**](https://github.com/mandiant/capa). +Scaricalo dal [**Github repo**](https://github.com/mandiant/capa). ### IOCs -IOC significa Indicator Of Compromise (Indicatore di Compromissione). Un IOC è un insieme di **condizioni che identificano** un software potenzialmente indesiderato o un **malware** confermato. I Blue Teams usano questo tipo di definizioni per **cercare questo tipo di file malevoli** nei loro **sistemi** e **reti**.\ -Condividere queste definizioni è molto utile: quando un malware viene identificato in un computer e viene creato un IOC per quel malware, altri Blue Teams possono usarlo per identificare il malware più velocemente. +IOC significa Indicator Of Compromise. Un IOC è un insieme di **condizioni che identificano** del software potenzialmente indesiderato o confermato **malware**. Le Blue Teams usano questo tipo di definizione per **cercare questo tipo di file maligni** nei loro **sistemi** e **reti**.\ +Condividere queste definizioni è molto utile: quando il malware viene identificato in un computer e viene creato un IOC per quel malware, altre Blue Teams possono usarlo per identificare il malware più rapidamente. -Uno strumento per creare o modificare IOCs è [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ +Uno strumento per creare o modificare gli IOC è [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\ Puoi usare strumenti come [**Redline**](https://www.fireeye.com/services/freeware/redline.html) per **cercare IOCs definiti in un dispositivo**. ### Loki -[**Loki**](https://github.com/Neo23x0/Loki) è uno scanner per semplici Indicatori di Compromissione.\ -La detection si basa su quattro metodi di rilevamento: +[**Loki**](https://github.com/Neo23x0/Loki) è uno scanner per Simple Indicators of Compromise.\ +La rilevazione si basa su quattro metodi di rilevamento: ``` 1. File Name IOC Regex match on full file path/name @@ -92,7 +92,7 @@ Compares process connection endpoints with C2 IOCs (new since version v.10) ``` ### Linux Malware Detect -[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) è uno scanner per malware per Linux rilasciato sotto la licenza GNU GPLv2, progettato attorno alle minacce affrontate negli ambienti di hosting condiviso. Utilizza dati sulle minacce provenienti dai sistemi di intrusion detection al perimetro di rete per estrarre malware attivamente impiegati negli attacchi e genera firme per la rilevazione. Inoltre, i dati sulle minacce derivano anche dalle segnalazioni degli utenti tramite la funzionalità LMD checkout e dalle risorse della community malware. +[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) è uno scanner di malware per Linux rilasciato sotto licenza GNU GPLv2, progettato per le minacce presenti negli ambienti hosting condivisi. Utilizza dati sulle minacce provenienti da network edge intrusion detection systems per estrarre il malware attivamente impiegato negli attacchi e genera firme per il rilevamento. Inoltre, i dati sulle minacce derivano anche dalle segnalazioni degli utenti tramite la funzionalità LMD checkout e dalle risorse della community del malware. ### rkhunter @@ -102,31 +102,31 @@ sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--sk ``` ### FLOSS -[**FLOSS**](https://github.com/mandiant/flare-floss) è uno strumento che cerca di trovare stringhe offuscate all'interno di eseguibili usando diverse tecniche. +[**FLOSS**](https://github.com/mandiant/flare-floss) è uno strumento che tenta di trovare obfuscated strings all'interno di executables usando diverse tecniche. ### PEpper -[PEpper ](https://github.com/Th3Hurrican3/PEpper)controlla alcune informazioni di base all'interno dell'eseguibile (binary data, entropy, URLs and IPs, some yara rules). +[PEpper ](https://github.com/Th3Hurrican3/PEpper)controlla alcune informazioni di base nell'executable (binary data, entropy, URLs and IPs, some yara rules). ### PEstudio -[PEstudio](https://www.winitor.com/download) è uno strumento che permette di ottenere informazioni sui Windows executables come imports, exports, headers, ma controllerà anche virus total e troverà potenziali Att\&ck techniques. +[PEstudio](https://www.winitor.com/download) è uno strumento che permette di ottenere informazioni sui Windows executables come imports, exports, headers, ma controlla anche virus total e individua potenziali Att\&ck techniques. ### Detect It Easy(DiE) -[**DiE**](https://github.com/horsicq/Detect-It-Easy/) è uno strumento per rilevare se un file è criptato e trovare anche packers. +[**DiE**](https://github.com/horsicq/Detect-It-Easy/) è uno strumento per rilevare se un file è **encrypted** e anche trovare **packers**. ### NeoPI -[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI) è uno script Python che utilizza vari metodi statistici per rilevare contenuti offuscati e criptati all'interno di file di testo/script. Lo scopo di NeoPI è aiutare nel rilevamento di codice web shell nascosto. +[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is a Python script che utilizza una varietà di **statistical methods** per rilevare contenuti **obfuscated** e **encrypted** all'interno di file di testo/script. Lo scopo di NeoPI è aiutare nella **detection of hidden web shell code**. ### **php-malware-finder** -[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fa del suo meglio per rilevare codice offuscato/sospetto nonché file che usano funzioni PHP spesso usate in malwares/webshells. +[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fa del suo meglio per rilevare **obfuscated**/**dodgy code** così come file che utilizzano funzioni **PHP** spesso usate in **malwares**/webshells. ### Apple Binary Signatures -Quando si controlla un **campione di malware** dovresti sempre **verificare la firma** del binario, poiché il **sviluppatore** che lo ha firmato potrebbe essere già **collegato** al **malware.** +Quando si analizza un **malware sample** dovresti sempre **check the signature** del binary, poiché il **developer** che lo ha firmato potrebbe essere già **related** con **malware.** ```bash #Get signer codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier" @@ -141,21 +141,21 @@ spctl --assess --verbose /Applications/Safari.app ### File Stacking -Se sai che una cartella contenente i **file** di un web server è stata **aggiornata l'ultima volta in una certa data**, **controlla** le **date** di creazione e modifica di tutti i **file** nel **web server** e, se qualche data è **sospetta**, esamina quel file. +Se sai che una cartella contenente i **file** di un web server è stata **aggiornata l'ultima volta in una certa data**, **controlla** la **data** in cui tutti i **file** nel **web server** sono stati creati e modificati e, se qualche data è **sospetta**, analizza quel file. -### Baselines +### Linee di base -Se i file di una cartella **non dovevano essere modificati**, puoi calcolare l'**hash** dei **file originali** della cartella e **confrontarlo** con quelli **correnti**. Qualsiasi modifica sarà **sospetta**. +Se i file di una cartella **non avrebbero dovuto essere modificati**, puoi calcolare l'**hash** dei **file originali** della cartella e **confrontarlo** con quelli **correnti**. Qualsiasi modifica sarà **sospetta**. -### Statistical Analysis +### Analisi statistica -Quando le informazioni sono salvate nei log puoi **controllare statistiche come quante volte ogni file del web server è stato richiesto**, poiché una web shell potrebbe essere tra i file più richiesti. +Quando le informazioni sono salvate nei log puoi **controllare statistiche** come quante volte è stato accesso ciascun file del web server, poiché una web shell potrebbe essere uno dei file più accessi. --- ### Android in-app native telemetry (no root) -Su Android puoi strumentare il codice nativo all'interno del processo dell'app target precaricando una piccola libreria logger prima che altre librerie JNI si inizializzino. Questo fornisce visibilità precoce sul comportamento nativo senza hook a livello di sistema o root. Un approccio popolare è SoTap: inserire libsotap.so per la ABI corretta nell'APK e iniettare una chiamata System.loadLibrary("sotap") in anticipo (es. static initializer o Application.onCreate), quindi raccogliere i log da percorsi interni/esterni o, in alternativa, da Logcat. +Su Android, puoi strumentare codice nativo all'interno del processo dell'app target precaricando una piccola libreria logger prima che le altre librerie JNI vengano inizializzate. Questo fornisce visibilità precoce sul comportamento nativo senza hook di sistema o root. Un approccio popolare è SoTap: inserire libsotap.so per l'ABI corretto nell'APK e iniettare una chiamata System.loadLibrary("sotap") in fase iniziale (ad es., static initializer o Application.onCreate), quindi raccogliere i log da percorsi interni/esterni o usare Logcat come fallback. See the Android native reversing page for setup details and log paths: @@ -165,13 +165,13 @@ See the Android native reversing page for setup details and log paths: --- -## Deoffuscamento del Dynamic Control-Flow (JMP/CALL RAX Dispatchers) +## Deobfuscazione del controllo di flusso dinamico (JMP/CALL RAX Dispatchers) -Famiglie di malware moderne abusano pesantemente dell'obfuscazione del Control-Flow Graph (CFG): invece di un jump/call diretto calcolano la destinazione a run-time ed eseguono un `jmp rax` o `call rax`. Un piccolo *dispatcher* (tipicamente nove istruzioni) imposta l'obiettivo finale in base ai flag della CPU `ZF`/`CF`, compromettendo completamente il recupero statico del CFG. +Le famiglie di malware moderne abusano pesantemente dell'offuscamento del Control-Flow Graph (CFG): invece di un jump/call diretto calcolano la destinazione a runtime ed eseguono un `jmp rax` o `call rax`. Un piccolo *dispatcher* (tipicamente nove istruzioni) imposta il target finale a seconda dei flag della CPU `ZF`/`CF`, compromettendo completamente il recupero statico del CFG. -La tecnica – dimostrata dal loader SLOW#TEMPEST – può essere sconfitta con un flusso di lavoro in tre passi che si basa solo su IDAPython e l'Unicorn CPU emulator. +La tecnica — mostrata dal loader SLOW#TEMPEST — può essere neutralizzata con un flusso di lavoro in tre passaggi che si basa solamente su IDAPython e sull'emulatore CPU Unicorn. -### 1. Locate every indirect jump / call +### 1. Individuare ogni indirect jump / call ```python import idautils, idc @@ -195,7 +195,7 @@ size = jmp_ea + idc.get_item_size(jmp_ea) - start code = idc.get_bytes(start, size) open(f"{start:X}.bin", "wb").write(code) ``` -### 3. Emularlo due volte con Unicorn +### 3. Emulalo due volte con Unicorn ```python from unicorn import * from unicorn.x86_const import * @@ -211,9 +211,9 @@ mu.reg_write(UC_X86_REG_RAX, 0) mu.emu_start(BASE, BASE+len(code)) return mu.reg_read(UC_X86_REG_RAX) ``` -Esegui `run(code,0,0)` e `run(code,1,1)` per ottenere le destinazioni dei branch *false* e *true*. +Esegui `run(code,0,0)` e `run(code,1,1)` per ottenere i target dei rami *false* e *true*. -### 4. Ripristinare un direct jump / call +### 4. Ripristinare tramite patch un jump / call diretto ```python import struct, ida_bytes @@ -222,22 +222,22 @@ op = 0xE8 if is_call else 0xE9 # CALL rel32 or JMP rel32 disp = target - (ea + 5) & 0xFFFFFFFF ida_bytes.patch_bytes(ea, bytes([op]) + struct.pack(' cat lib/arm64-v8a/libfoo.so" > libfoo.so # Or from the APK (zip) unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/ ``` -2. **Identifica architettura e protezioni** +2. **Identify architecture & protections** ```bash file libfoo.so # arm64 or arm32 / x86 readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc. checksec --file libfoo.so # (peda/pwntools) ``` -3. **Elenca simboli esportati e binding JNI** +3. **List exported symbols & JNI bindings** ```bash readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI ``` -4. **Caricalo in un decompilatore** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper o Cutter/Rizin) e avvia l'analisi automatica. -Le versioni più recenti di Ghidra hanno introdotto un decompilatore AArch64 che riconosce PAC/BTI stubs e tag MTE, migliorando molto l'analisi delle librerie compilate con l'Android 14 NDK. -5. **Decidi tra reversing statico e dinamico:** codice stripped/obfuscated spesso richiede *instrumentation* (Frida, ptrace/gdbserver, LLDB). +4. **Load in a decompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) and run auto-analysis. +Le versioni più recenti di Ghidra hanno introdotto un decompiler AArch64 che riconosce PAC/BTI stubs e MTE tags, migliorando notevolmente l'analisi delle librerie compilate con l'NDK di Android 14. +5. **Decide on static vs dynamic reversing:** il codice stripped e offuscato spesso necessita di *instrumentation* (Frida, ptrace/gdbserver, LLDB). --- ### Instrumentazione dinamica (Frida ≥ 16) -La serie 16 di Frida ha introdotto diverse migliorie specifiche per Android che aiutano quando il target usa le ottimizzazioni moderne di Clang/LLD: +La serie 16 di Frida ha introdotto diversi miglioramenti specifici per Android che aiutano quando il target usa ottimizzazioni moderne di Clang/LLD: -* `thumb-relocator` can now *hook tiny ARM/Thumb functions* generated by LLD’s aggressive alignment (`--icf=all`). -* L'enumerazione e il rebinding degli *ELF import slots* funziona su Android, consentendo il patching per-modulo via `dlopen()`/`dlsym()` quando gli inline hooks vengono rifiutati. +* `thumb-relocator` può ora *hook tiny ARM/Thumb functions* generate dall'allineamento aggressivo di LLD (`--icf=all`). +* L'enumerazione e il rebinding degli *ELF import slots* funziona su Android, permettendo il patching `dlopen()`/`dlsym()` per modulo quando gli inline hooks vengono rifiutati. * Il Java hooking è stato corretto per il nuovo **ART quick-entrypoint** usato quando le app sono compilate con `--enable-optimizations` su Android 14. -Esempio: enumerare tutte le funzioni registrate tramite `RegisterNatives` e fare il dump dei loro indirizzi a runtime: +Esempio: enumerare tutte le funzioni registrate tramite `RegisterNatives` e dumpare i loro indirizzi a runtime: ```javascript Java.perform(function () { var Runtime = Java.use('java.lang.Runtime'); @@ -61,21 +61,21 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met }); }); ``` -Frida funzionerà immediatamente su dispositivi PAC/BTI-enabled (Pixel 8/Android 14+) purché si usi frida-server 16.2 o successivo – le versioni precedenti non riuscivano a individuare il padding per gli inline hooks. +Frida funzionerà immediatamente su dispositivi con PAC/BTI abilitato (Pixel 8/Android 14+) purché si usi frida-server 16.2 o successivo - le versioni precedenti non riuscivano a trovare il padding per gli inline hooks. -### Telemetria JNI locale al processo tramite .so precaricato (SoTap) +### Process-local JNI telemetry via preloaded .so (SoTap) -Quando una strumentazione completa è eccessiva o bloccata, puoi comunque ottenere visibilità a livello nativo precaricando un piccolo logger all'interno del processo target. SoTap è una libreria nativa Android leggera (.so) che registra il comportamento a runtime di altre librerie JNI (.so) all'interno dello stesso processo dell'app (non richiede root). +Quando un'instrumentation completa è eccessiva o bloccata, è comunque possibile ottenere visibilità a livello nativo precaricando un piccolo logger all'interno del processo target. SoTap è una libreria nativa Android leggera (.so) che registra il comportamento runtime di altre librerie JNI (.so) all'interno dello stesso processo dell'app (no root required). Key properties: -- Initializes early and observes JNI/native interactions inside the process that loads it. -- Persists logs using multiple writable paths with graceful fallback to Logcat when storage is restricted. -- Source-customizable: edit sotap.c to extend/adjust what gets logged and rebuild per ABI. +- Si inizializza precocemente e osserva le interazioni JNI/native all'interno del processo che lo carica. +- Persiste i log utilizzando più percorsi scrivibili con fallback elegante a Logcat quando lo storage è ristretto. +- Personalizzabile a livello di sorgente: modifica sotap.c per estendere/adeguare cosa viene registrato e ricompila per ABI. Setup (repack the APK): 1) Drop the proper ABI build into the APK so the loader can resolve libsotap.so: -- lib/arm64-v8a/libsotap.so (per arm64) -- lib/armeabi-v7a/libsotap.so (per arm32) +- lib/arm64-v8a/libsotap.so (for arm64) +- lib/armeabi-v7a/libsotap.so (for arm32) 2) Ensure SoTap loads before other JNI libs. Inject a call early (e.g., Application subclass static initializer or onCreate) so the logger is initialized first. Smali snippet example: ```smali const-string v0, "sotap" @@ -91,31 +91,31 @@ Log paths (checked in order): /sdcard/Download/sotap-%s.log # If all fail: fallback to Logcat only ``` -Note e risoluzione problemi: -- L'allineamento ABI è obbligatorio. Una mancata corrispondenza solleverà UnsatisfiedLinkError e il logger non si caricherà. -- I vincoli di storage sono comuni su Android moderno; se le scritture su file falliscono, SoTap continuerà comunque a emettere tramite Logcat. -- Il comportamento/verbosità è pensato per essere personalizzato; ricompila dal sorgente dopo aver modificato sotap.c. +Note e risoluzione dei problemi: +- L'allineamento ABI è obbligatorio. Un mismatch provocherà UnsatisfiedLinkError e il logger non verrà caricato. +- Le limitazioni di storage sono comuni su Android moderni; se le scritture su file falliscono, SoTap continuerà comunque a emettere tramite Logcat. +- Comportamento/verbosità è pensato per essere personalizzato; ricompila dal sorgente dopo aver modificato sotap.c. -Questo approccio è utile per il triage di malware e il debugging JNI, dove osservare i flussi di chiamate native dall'avvio del processo è critico ma non sono disponibili hook a livello di root/sistema. +This approach is useful for malware triage and JNI debugging where observing native call flows from process start is critical but root/system-wide hooks aren’t available. --- ### Vulnerabilità recenti da cercare negli APK -| Year | CVE | Affected library | Notes | -|------|-----|------------------|-------| -|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow raggiungibile dal codice nativo che decodifica immagini WebP. Diverse app Android includono versioni vulnerabili. Quando trovi un `libwebp.so` dentro un APK, controllane la versione e prova a sfruttarla o a patcharla.| | -|2024|Multiple|OpenSSL 3.x series|Diversi problemi di sicurezza della memoria e padding-oracle. Molti bundle Flutter & ReactNative includono il proprio `libcrypto.so`.| +| Anno | CVE | Libreria interessata | Note | +|------|-----|----------------------|------| +|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow reachable from native code that decodes WebP images. Several Android apps bundle vulnerable versions. When you see a `libwebp.so` inside an APK, check its version and attempt exploitation or patching.| | +|2024|Multiple|OpenSSL 3.x series|Several memory-safety and padding-oracle issues. Many Flutter & ReactNative bundles ship their own `libcrypto.so`.| -Quando trovi file `.so` di *terze parti* dentro un APK, verifica sempre il loro hash rispetto agli avvisi upstream. SCA (Software Composition Analysis) è poco diffusa su mobile, quindi build vulnerabili e datate sono comuni. +When you spot *third-party* `.so` files inside an APK, always cross-check their hash against upstream advisories. SCA (Software Composition Analysis) is uncommon on mobile, so outdated vulnerable builds are rampant. --- ### Tendenze Anti-Reversing & Hardening (Android 13-15) -* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 abilita PAC/BTI nelle librerie di sistema su siliconi ARMv8.3+ supportati. I decompiler ora mostrano pseudo-istruzioni correlate a PAC; per l'analisi dinamica Frida inietta trampolini *dopo* aver rimosso PAC, ma i tuoi trampolini personalizzati dovrebbero chiamare `pacda`/`autibsp` dove necessario. -* **MTE & Scudo hardened allocator:** il memory-tagging è opt-in ma molte app che usano Play-Integrity compilano con `-fsanitize=memtag`; usa `setprop arm64.memtag.dump 1` più `adb shell am start ...` per catturare i tag faults. -* **LLVM Obfuscator (opaque predicates, control-flow flattening):** i packer commerciali (es. Bangcle, SecNeo) proteggono sempre più il codice *nativo*, non solo Java; aspettati bogus control-flow e blob di stringhe cifrate in `.rodata`. +* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 abilita PAC/BTI nelle librerie di sistema su siliconi ARMv8.3+ supportati. I decompilatori ora mostrano pseudo-istruzioni correlate a PAC; per l'analisi dinamica Frida inietta trampolines *after* stripping PAC, ma i tuoi trampolines personalizzati dovrebbero chiamare `pacda`/`autibsp` quando necessario. +* **MTE & Scudo hardened allocator:** il memory-tagging è opt-in ma molte app Play-Integrity aware vengono compilate con `-fsanitize=memtag`; usa `setprop arm64.memtag.dump 1` più `adb shell am start ...` per catturare tag faults. +* **LLVM Obfuscator (opaque predicates, control-flow flattening):** i packer commerciali (e.g., Bangcle, SecNeo) proteggono sempre di più il codice *native*, non solo Java; aspettati bogus control-flow e blob di stringhe cifrate in `.rodata`. --- @@ -131,6 +131,6 @@ Quando trovi file `.so` di *terze parti* dentro un APK, verifica sempre il loro - Avviso NVD per l'overflow di `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) - SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) - SoTap Releases – [github.com/RezaArbabBot/SoTap/releases](https://github.com/RezaArbabBot/SoTap/releases) -- How to work with SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) +- Come lavorare con SoTap? – [t.me/ForYouTillEnd/13](https://t.me/ForYouTillEnd/13) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/smali-changes.md b/src/mobile-pentesting/android-app-pentesting/smali-changes.md index 1cce68ff8..81572e83d 100644 --- a/src/mobile-pentesting/android-app-pentesting/smali-changes.md +++ b/src/mobile-pentesting/android-app-pentesting/smali-changes.md @@ -1,15 +1,15 @@ -# Smali - Decompilazione/[Modifica]/Compilazione +# Smali - Decompilare/[Modificare]/Compilare {{#include ../../banners/hacktricks-training.md}} -A volte è interessante modificare il codice dell'applicazione per accedere a informazioni nascoste (magari password ben offuscate o flags). In questo caso può essere utile decompilare l'apk, modificare il codice e ricompilarlo. +A volte è interessante modificare il codice dell'applicazione per accedere a informazioni nascoste per te (magari password ben offuscate o flags). In questo caso può essere utile decompilare l'apk, modificare il codice e ricompilarlo. -**Riferimento agli opcodes:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) +**Riferimento opcodes:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) ## Metodo veloce -Usando **Visual Studio Code** e l'estensione [APKLab](https://github.com/APKLab/APKLab), puoi **decompilare automaticamente**, modificare, **ricompilare**, firmare e installare l'applicazione senza eseguire comandi. +Usando **Visual Studio Code** e l'estensione [APKLab](https://github.com/APKLab/APKLab), puoi **decompilare automaticamente**, modificare, **ricompilare**, firmare & installare l'applicazione senza eseguire alcun comando. Un altro **script** che facilita molto questo compito è [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh) @@ -19,39 +19,39 @@ Usando APKTool puoi accedere al **codice smali e alle risorse**: ```bash apktool d APP.apk ``` -Se **apktool** ti dà un errore, prova[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) +Se **apktool** ti dà un errore, prova a [installare la **ultima versione**](https://ibotpeaches.github.io/Apktool/install/) -Alcuni **file interessanti che dovresti esaminare** sono: +Alcuni **file interessanti da controllare** sono: - _res/values/strings.xml_ (and all xmls inside res/values/*) - _AndroidManifest.xml_ - Any file with extension _.sqlite_ or _.db_ -Se `apktool` ha **problemi nel decodificare l'applicazione** consulta [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) o prova a usare l'argomento **`-r`** (Non decodificare le risorse). In questo modo, se il problema era in una risorsa e non nel codice sorgente, non avrai il problema (non decompilerai nemmeno le risorse). +Se `apktool` ha **problemi a decodificare l'applicazione** dai un'occhiata a [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) oppure prova a usare l'argomento **`-r`** (Non decodificare le risorse). In questo modo, se il problema era in una risorsa e non nel codice sorgente, non avrai il problema (e non decompilerai nemmeno le risorse). ## Modificare il codice smali -Puoi **modificare** le **istruzioni**, cambiare il **valore** di alcune variabili o **aggiungere** nuove istruzioni. Io modifico il codice Smali usando [**VS Code**](https://code.visualstudio.com), poi installa la **smalise extension** e l'editor ti dirà se qualche **istruzione è errata**.\ -Some **examples** can be found here: +Puoi **modificare** le **istruzioni**, cambiare il **valore** di alcune variabili o **aggiungere** nuove istruzioni. Io modifico il codice Smali usando [**VS Code**](https://code.visualstudio.com), poi installi l'**smalise extension** e l'editor ti dirà se qualche **istruzione è errata**.\ +Alcuni **esempi** possono essere trovati qui: - [Smali changes examples](smali-changes.md) - [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md) -Or you can [**check below some Smali changes explained**](smali-changes.md#modifying-smali). +Oppure puoi [**controllare sotto alcuni cambiamenti Smali spiegati**](smali-changes.md#modifying-smali). ## Ricompilare l'APK -Dopo aver modificato il codice puoi **ricompilare** l'APK usando: +Dopo aver modificato il codice puoi **ricompilare** il codice usando: ```bash apktool b . #In the folder generated when you decompiled the application ``` Questo **compilerà** il nuovo APK **all'interno** della cartella _**dist**_. -Se **apktool** genera un **errore**, prova[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/) +Se **apktool** genera un **errore**, prova a [installare la **versione più recente**](https://ibotpeaches.github.io/Apktool/install/) ### **Firma il nuovo APK** -Poi, devi **generare una chiave** (ti verrà chiesta una password e alcune informazioni che puoi compilare casualmente): +Poi devi **generare una chiave** (ti verrà chiesto di inserire una password e alcune informazioni che puoi compilare a caso): ```bash keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias ``` @@ -59,9 +59,9 @@ Infine, **firma** il nuovo APK: ```bash jarsigner -keystore key.jks path/to/dist/* ``` -### Ottimizza la nuova applicazione +### Ottimizzare la nuova applicazione -**zipalign** è uno strumento di allineamento degli archivi che fornisce importanti ottimizzazioni ai file delle applicazioni Android (APK). [More information here](https://developer.android.com/studio/command-line/zipalign). +**zipalign** è uno strumento di allineamento di archivi che fornisce un'importante ottimizzazione per Android application (APK) files. [Maggiori informazioni qui](https://developer.android.com/studio/command-line/zipalign). ```bash zipalign [-f] [-v] infile.apk outfile.apk zipalign -v 4 infile.apk @@ -90,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V return-void .end method ``` -L'insieme di istruzioni Smali è disponibile [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). +Il set di istruzioni Smali è disponibile [qui](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions). ### Modifiche leggere ### Modificare i valori iniziali di una variabile all'interno di una funzione -Alcune variabili sono definite all'inizio della funzione usando l'opcode _const_; puoi modificare i loro valori oppure puoi definirne di nuove: +Alcune variabili sono definite all'inizio della funzione usando l'opcode _const_; puoi modificarne i valori, oppure definirne di nuovi: ```bash #Number const v9, 0xf4240 @@ -127,9 +127,9 @@ iput v0, p0, Lcom/google/ctf/shallweplayagame/GameActivity;->o:I #Save v0 inside if-ne v0, v9, :goto_6 #If not equals, go to: :goto_6 goto :goto_6 #Always go to: :goto_6 ``` -### Cambiamenti maggiori +### Modifiche principali -### Logging +### Registrazione dei log ```bash #Log win: iget v5, p0, Lcom/google/ctf/shallweplayagame/GameActivity;->o:I #Get this.o inside v5 @@ -141,16 +141,16 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin Raccomandazioni: - Se intendi usare variabili dichiarate all'interno della funzione (dichiarate v0,v1,v2...) inserisci queste righe tra _.local _ e le dichiarazioni delle variabili (_const v0, 0x1_) -- Se vuoi inserire il logging nel mezzo del codice di una funzione: -- Aggiungi 2 al numero di variabili dichiarate: Es.: da _.locals 10_ a _.locals 12_ -- Le nuove variabili devono essere i numeri successivi rispetto alle variabili già dichiarate (in questo esempio devono essere _v10_ e _v11_, ricorda che si parte da v0). -- Cambia il codice della funzione di logging e usa _v10_ e _v11_ invece di _v5_ e _v1_. +- Se vuoi inserire il codice di logging nel mezzo del codice di una funzione: +- Aggiungi 2 al numero di variabili dichiarate: Es: da _.locals 10_ a _.locals 12_ +- Le nuove variabili dovrebbero essere i numeri successivi rispetto alle variabili già dichiarate (in questo esempio saranno _v10_ e _v11_, ricorda che si parte da v0). +- Modifica il codice della funzione di logging e usa _v10_ e _v11_ invece di _v5_ e _v1_. ### Toasting Ricorda di aggiungere 3 al numero di _.locals_ all'inizio della funzione. -Questo codice è pronto per essere inserito nel **mezzo di una funzione** (**modifica** il numero delle **variabili** secondo necessità). Prenderà il **valore di this.o**, lo **trasformerà** in **String** e poi **mostrerà** un **toast** con il suo valore. +Questo codice è pronto per essere inserito nel **mezzo di una funzione** (**modifica** il numero delle **variabili** se necessario). Prenderà il **valore di this.o**, lo **trasformerà** in **String** e poi **mostrerà** un **toast** con il suo valore. ```bash const/4 v10, 0x1 const/4 v11, 0x1 @@ -164,7 +164,7 @@ invoke-virtual {v12}, Landroid/widget/Toast;->show()V ``` ### Caricamento di una libreria nativa all'avvio (System.loadLibrary) -A volte è necessario precaricare una libreria nativa affinché si inizializzi prima di altre librerie JNI (es., per abilitare telemetry/logging a livello di processo). Puoi iniettare una chiamata a System.loadLibrary() in un inizializzatore statico o all'inizio di Application.onCreate(). Esempio di smali per un inizializzatore di classe statico (): +A volte è necessario precaricare una libreria nativa in modo che si inizializzi prima di altre librerie JNI (ad es., per abilitare telemetria/logging locale al processo). Puoi iniettare una chiamata a System.loadLibrary() in un static initializer o all'inizio di Application.onCreate(). Esempio smali per un static class initializer (): ```smali .class public Lcom/example/App; .super Landroid/app/Application; @@ -176,7 +176,7 @@ invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V return-void .end method ``` -In alternativa, posiziona le stesse due istruzioni all'inizio del tuo Application.onCreate() per garantire che la libreria venga caricata il prima possibile: +In alternativa, posiziona le stesse due istruzioni all'inizio del tuo Application.onCreate() per assicurarti che la libreria venga caricata il prima possibile: ```smali .method public onCreate()V .locals 1 @@ -194,6 +194,6 @@ Note: ## Riferimenti -- SoTap: logger leggero in-app per il comportamento di JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) +- SoTap: Logger leggero in-app del comportamento JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap) {{#include ../../banners/hacktricks-training.md}}