maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-methodologies-and-resources/basic-forensic-meth

Browse Source
This commit is contained in:
Translator 2025-09-04 02:39:54 +00:00
parent b646e9ae9c
commit e148aa236f
3 changed files with 197 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
src/generic-methodologies-and-resources/basic-forensic-methodology/malware-analysis.md
View File

@ -1,12 +1,12 @@
# Analisi del Malware
# Malware Analysis
{{#include ../../banners/hacktricks-training.md}}
## CheatSheets di Forense
## Forensics CheatSheets
[https://www.jaiminton.com/cheatsheet/DFIR/#](https://www.jaiminton.com/cheatsheet/DFIR/)
## Servizi Online
## Servizi online
- [VirusTotal](https://www.virustotal.com/gui/home/upload)
- [HybridAnalysis](https://www.hybrid-analysis.com)
@ -14,18 +14,18 @@
- [Intezer](https://analyze.intezer.com)
- [Any.Run](https://any.run/)
## Strumenti Antivirus e di Rilevamento Offline
## Strumenti antivirus e di rilevamento offline
### Yara
#### Installa
#### Installazione
```bash
sudo apt-get install -y yara
```
#### Preparare le regole
Usa questo script per scaricare e unire tutte le regole yara per malware da github: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Crea la directory _**rules**_ ed eseguila. Questo creerà un file chiamato _**malware_rules.yar**_ che contiene tutte le regole yara per malware.
Crea la directory _**rules**_ ed esegui lo script. Questo creerà un file chiamato _**malware_rules.yar**_ che contiene tutte le regole yara per malware.
```bash
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
@ -36,16 +36,16 @@ 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: Controlla il malware e crea regole
#### YaraGen: Controllare malware e creare regole
Puoi utilizzare lo strumento [**YaraGen**](https://github.com/Neo23x0/yarGen) per generare regole yara da un binario. Dai un'occhiata a questi tutorial: [**Parte 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Parte 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Parte 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 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/)
```bash
python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m ../../mals/
```
### ClamAV
#### Installa
#### Installazione
```
sudo apt-get install -y clamav
```
@ -57,26 +57,26 @@ clamscan folderpath #Scan the whole folder
```
### [Capa](https://github.com/mandiant/capa)
**Capa** rileva potenziali **capacità** malevole in eseguibili: PE, ELF, .NET. Quindi troverà cose come tattiche Att\&ck, o capacità sospette come:
**Capa** rileva potenzialmente **malicious capabilities** in eseguibili: PE, ELF, .NET. Quindi troverà cose come Att\&ck tactics, o capabilities sospette come:
- controlla per errori OutputDebugString
- esegui come servizio
- crea processo
- check for OutputDebugString error
- run as a service
- create process
Ottienilo nel [**Github repo**](https://github.com/mandiant/capa).
Scaricalo nel [**Github repo**](https://github.com/mandiant/capa).
### IOCs
IOC significa Indicatore di Compromissione. Un IOC è un insieme di **condizioni che identificano** alcuni software potenzialmente indesiderati o **malware** confermato. I Blue Teams usano questo tipo di definizione per **cercare questo tipo di file malevoli** nei loro **sistemi** e **reti**.\
Condividere queste definizioni è molto utile poiché quando il malware viene identificato in un computer e viene creato un IOC per quel malware, altri Blue Teams possono usarlo per identificare il malware più rapidamente.
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.
Uno strumento per creare o modificare IOCs è [**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 Indicatori di Compromissione Semplici.\
La rilevazione si basa su quattro metodi di rilevazione:
[**Loki**](https://github.com/Neo23x0/Loki) è uno scanner per semplici Indicatori di Compromissione.\
La detection si basa su quattro metodi di rilevamento:
```
1. File Name IOC
Regex match on full file path/name
@ -92,41 +92,41 @@ 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 di malware per Linux rilasciato sotto la licenza GNU GPLv2, progettato attorno alle minacce affrontate negli ambienti di hosting condivisi. Utilizza dati sulle minacce provenienti dai sistemi di rilevamento delle intrusioni ai margini della rete per estrarre malware che viene attivamente utilizzato negli attacchi e genera firme per la rilevazione. Inoltre, i dati sulle minacce sono anche derivati dalle segnalazioni degli utenti con la funzione di checkout di LMD e dalle risorse della comunità malware.
[**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.
### rkhunter
Strumenti come [**rkhunter**](http://rkhunter.sourceforge.net) possono essere utilizzati per controllare il filesystem per possibili **rootkit** e malware.
Strumenti come [**rkhunter**](http://rkhunter.sourceforge.net) possono essere usati per controllare il filesystem alla ricerca di possibili **rootkits** e malware.
```bash
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
```
### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) è uno strumento che cerca di trovare stringhe offuscate all'interno di eseguibili utilizzando diverse tecniche.
[**FLOSS**](https://github.com/mandiant/flare-floss) è uno strumento che cerca di trovare stringhe offuscate all'interno di eseguibili usando diverse tecniche.
### PEpper
[PEpper ](https://github.com/Th3Hurrican3/PEpper)controlla alcune informazioni di base all'interno dell'eseguibile (dati binari, entropia, URL e IP, alcune regole yara).
[PEpper ](https://github.com/Th3Hurrican3/PEpper)controlla alcune informazioni di base all'interno dell'eseguibile (binary data, entropy, URLs and IPs, some yara rules).
### PEstudio
[PEstudio](https://www.winitor.com/download) è uno strumento che consente di ottenere informazioni sugli eseguibili Windows come importazioni, esportazioni, intestazioni, ma controlla anche virus total e trova potenziali tecniche Att\&ck.
[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.
### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) è uno strumento per rilevare se un file è **crittografato** e trova anche **packers**.
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) è uno strumento per rilevare se un file è criptato e trovare anche packers.
### NeoPI
[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)è uno script Python che utilizza una varietà di **metodi statistici** per rilevare contenuti **offuscati** e **crittografati** all'interno di file di testo/script. Lo scopo di NeoPI è aiutare nella **rilevazione di codice web shell nascosto**.
[**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.
### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) fa del suo meglio per rilevare **codice offuscato**/**sospetto** così come file che utilizzano funzioni **PHP** spesso usate in **malware**/webshell.
[**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.
### Apple Binary Signatures
Quando controlli un **campione di malware** dovresti sempre **controllare la firma** del binario poiché il **sviluppatore** che l'ha firmato potrebbe essere già **relato** a **malware.**
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.**
```bash
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -137,29 +137,41 @@ codesign --verify --verbose /Applications/Safari.app
#Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app
```
## Tecniche di Rilevamento
## Tecniche di rilevamento
### File Stacking
Se sai che una cartella contenente i **file** di un server web è stata **aggiornata l'ultima volta in una certa data**. **Controlla** la **data** in cui tutti i **file** nel **server web sono stati creati e modificati** e se qualche data è **sospetta**, controlla quel file.
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.
### Baselines
Se i file di una cartella **non avrebbero dovuto essere modificati**, puoi calcolare l'**hash** dei **file originali** della cartella e **confrontarli** con quelli **correnti**. Qualsiasi modifica sarà **sospetta**.
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**.
### Analisi Statistica
### Statistical Analysis
Quando le informazioni sono salvate nei log puoi **controllare statistiche come quante volte ogni file di un server web è stato accesso, poiché una shell web potrebbe essere una delle più**.
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.
---
## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers)
### Android in-app native telemetry (no root)
Le moderne famiglie di malware abusano pesantemente dell'oscuramento del Control-Flow Graph (CFG): invece di un salto/chiamata diretto, calcolano la destinazione a tempo di esecuzione ed eseguono un `jmp rax` o `call rax`. Un piccolo *dispatcher* (tipicamente nove istruzioni) imposta il target finale a seconda dei flag `ZF`/`CF` della CPU, rompendo completamente il recupero statico del CFG.
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.
La tecnica – mostrata dal caricatore SLOW#TEMPEST – può essere sconfitta con un flusso di lavoro in tre fasi che si basa solo su IDAPython e l'emulatore CPU Unicorn.
See the Android native reversing page for setup details and log paths:
### 1. Individua ogni salto / chiamata indiretta
{{#ref}}
../../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
{{#endref}}
---
## Deoffuscamento del Dynamic Control-Flow (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.
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.
### 1. Locate every indirect jump / call
```python
import idautils, idc
@ -183,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. Esegui l'emulazione due volte con Unicorn
### 3. Emularlo due volte con Unicorn
```python
from unicorn import *
from unicorn.x86_const import *
@ -199,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 i target dei rami *falsi* e *veri*.
Esegui `run(code,0,0)` e `run(code,1,1)` per ottenere le destinazioni dei branch *false* e *true*.
### 4. Ripristina un salto / chiamata diretta
### 4. Ripristinare un direct jump / call
```python
import struct, ida_bytes
@ -210,27 +222,28 @@ 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('<I', disp))
```
Dopo aver applicato la patch, costringi IDA a riesaminare la funzione in modo che il CFG completo e l'output di Hex-Rays vengano ripristinati:
Dopo aver applicato la patch, forza IDA a rianalizzare la funzione in modo che il CFG completo e l'output di Hex-Rays vengano ripristinati:
```python
import ida_auto, idaapi
idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
```
### 5. Etichetta le chiamate API indirette
### 5. Etichettare le chiamate API indirette
Una volta che la vera destinazione di ogni `call rax` è nota, puoi dire a IDA quale sia, in modo che i tipi di parametro e i nomi delle variabili vengano recuperati automaticamente:
Una volta noto il vero destinatario di ogni `call rax` puoi dire a IDA cosa sia così i tipi dei parametri & i nomi delle variabili vengano recuperati automaticamente:
```python
idc.set_callee_name(call_ea, resolved_addr, 0) # IDA 8.3+
```
### Vantaggi pratici
* Ripristina il vero CFG → la decompilazione passa da *10* righe a migliaia.
* Abilita il cross-reference delle stringhe & xrefs, rendendo la ricostruzione del comportamento banale.
* Gli script sono riutilizzabili: basta inserirli in qualsiasi loader protetto dallo stesso trucco.
* Ripristina il reale CFG → la decompilazione passa da *10* righe a migliaia.
* Abilita string-cross-reference & xrefs, rendendo la ricostruzione del comportamento banale.
* I Scripts sono riutilizzabili: inseriscili in qualsiasi loader protetto dallo stesso trucco.
---
## Riferimenti
- [Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques](https://unit42.paloaltonetworks.com/slow-tempest-malware-obfuscation/)
- SoTap: Lightweight in-app JNI (.so) behavior logger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}}

105
src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
View File

@ -1,47 +1,50 @@
# Reversing Native Libraries
# Reverse engineering delle librerie native
{{#include ../../banners/hacktricks-training.md}}
**Per ulteriori informazioni controlla:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
Le app Android possono utilizzare librerie native, tipicamente scritte in C o C++, per compiti critici in termini di prestazioni. Anche i creatori di malware abusano di queste librerie perché gli oggetti condivisi ELF sono ancora più difficili da decompilare rispetto al byte-code DEX/OAT. Questa pagina si concentra su flussi di lavoro *pratici* e *recenti* miglioramenti degli strumenti (2023-2025) che rendono più facile il reversing dei file `.so` di Android.
**Per ulteriori informazioni consulta:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
Le app Android possono usare librerie native, tipicamente scritte in C o C++, per task critici in termini di performance. Anche i creatori di malware abusano di queste librerie perché ELF shared objects sono ancora più difficili da decompilare rispetto a DEX/OAT byte-code.
Questa pagina si concentra su flussi di lavoro *pratici* e su miglioramenti *recenti* degli strumenti (2023-2025) che rendono più semplice il reversing dei file `.so` Android.
---
### Flusso di lavoro rapido per un `libfoo.so` appena estratto
### Flusso di triage rapido per una `libfoo.so` appena estratta
1. **Estrai la libreria**
```bash
# Da un'applicazione installata
# From an installed application
adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
# Oppure dall'APK (zip)
# Or from the APK (zip)
unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
```
2. **Identifica architettura e protezioni**
```bash
file libfoo.so # arm64 o arm32 / x86
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, ecc.
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**
```bash
readelf -s libfoo.so | grep ' Java_' # JNI dinamicamente collegato
strings libfoo.so | grep -i "RegisterNatives" -n # JNI registrato staticamente
readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI
strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI
```
4. **Carica 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 gli stub PAC/BTI e i tag MTE, migliorando notevolmente l'analisi delle librerie costruite con l'NDK Android 14.
5. **Decidi sul reversing statico vs dinamico:** codice strippato e offuscato spesso necessita di *strumentazione* (Frida, ptrace/gdbserver, LLDB).
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).
---
### Strumentazione Dinamica (Frida ≥ 16)
### Instrumentazione dinamica (Frida ≥ 16)
La serie 16 di Frida ha portato diversi miglioramenti specifici per Android che aiutano quando il target utilizza ottimizzazioni moderne di Clang/LLD:
La serie 16 di Frida ha introdotto diverse migliorie specifiche per Android che aiutano quando il target usa le ottimizzazioni moderne di Clang/LLD:
* `thumb-relocator` può ora *agganciare piccole funzioni ARM/Thumb* generate dall'allineamento aggressivo di LLD (`--icf=all`).
* L'enumerazione e il riutilizzo degli *slot di importazione ELF* funzionano su Android, abilitando il patching `dlopen()`/`dlsym()` per modulo quando gli hook inline vengono rifiutati.
* Il hooking Java è stato corretto per il nuovo **punto di ingresso rapido ART** utilizzato quando le app sono compilate con `--enable-optimizations` su Android 14.
* `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.
* 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 dumpare i loro indirizzi a runtime:
Esempio: enumerare tutte le funzioni registrate tramite `RegisterNatives` e fare il dump dei loro indirizzi a runtime:
```javascript
Java.perform(function () {
var Runtime = Java.use('java.lang.Runtime');
@ -58,38 +61,76 @@ console.log('[+] RegisterNatives on ' + clazz.getName() + ' -> ' + count + ' met
});
});
```
Frida funzionerà immediatamente su dispositivi abilitati PAC/BTI (Pixel 8/Android 14+) purché tu utilizzi frida-server 16.2 o versioni successive – le versioni precedenti non riuscivano a localizzare il padding per gli hook inline. citeturn5search2turn5search0
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.
### Telemetria JNI locale al processo tramite .so precaricato (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).
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.
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)
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"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
```
3) Rebuild/sign/install, run the app, then collect logs.
Log paths (checked in order):
```
/data/user/0/%s/files/sotap.log
/data/data/%s/files/sotap.log
/sdcard/Android/data/%s/files/sotap.log
/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.
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.
---
### Vulnerabilità recenti da cercare negli APK
| Anno | CVE | Libreria interessata | Note |
|------|-----|----------------------|-------|
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Overflow del buffer heap raggiungibile da codice nativo che decodifica immagini WebP. Diverse app Android includono versioni vulnerabili. Quando vedi un `libwebp.so` all'interno di un APK, controlla la sua versione e tenta di sfruttare o patchare.| citeturn2search0|
|2024|Multiple|OpenSSL 3.x series|Diverse problematiche di sicurezza della memoria e padding-oracle. Molti bundle Flutter & ReactNative includono il proprio `libcrypto.so`.|
| 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`.|
Quando noti file `.so` *di terze parti* all'interno di un APK, controlla sempre il loro hash rispetto agli avvisi upstream. L'SCA (Software Composition Analysis) è rara sui dispositivi mobili, quindi le build vulnerabili obsolete sono diffuse.
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.
---
### Tendenze Anti-Reversing & Hardening (Android 13-15)
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 abilita PAC/BTI nelle librerie di sistema su silicio ARMv8.3+ supportato. I decompilatori ora mostrano pseudo-istruzioni relative 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 allocatore rinforzato:** il tagging della memoria è facoltativo, ma molte app consapevoli di Play-Integrity vengono costruite con `-fsanitize=memtag`; usa `setprop arm64.memtag.dump 1` più `adb shell am start ...` per catturare errori di tag.
* **LLVM Obfuscator (predicati opachi, appiattimento del flusso di controllo):** i packer commerciali (ad es., Bangcle, SecNeo) proteggono sempre più il codice *nativo*, non solo Java; aspettati flussi di controllo falsi e blob di stringhe crittografate in `.rodata`.
* **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`.
---
### Risorse
- **Apprendimento dell'Assembly ARM:** [Azeria Labs – Fondamenti di Assembly ARM](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **Documentazione JNI & NDK:** [Specifica JNI di Oracle](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Suggerimenti JNI per Android](https://developer.android.com/training/articles/perf-jni) · [Guide NDK](https://developer.android.com/ndk/guides/)
- **Debugging delle librerie native:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
- **Learning ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **JNI & NDK Documentation:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Tips](https://developer.android.com/training/articles/perf-jni) · [NDK Guides](https://developer.android.com/ndk/guides/)
- **Debugging Native Libraries:** [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3)
### Riferimenti
- Change-log di Frida 16.x (hooking Android, rilocazione di funzioni piccole) – [frida.re/news](https://frida.re/news/) citeturn5search0
- Avviso NVD per overflow `libwebp` CVE-2023-4863 – [nvd.nist.gov](https://nvd.nist.gov/vuln/detail/CVE-2023-4863) citeturn2search0
- Frida 16.x change-log (Android hooking, tiny-function relocation) – [frida.re/news](https://frida.re/news/)
- 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)
{{#include ../../banners/hacktricks-training.md}}

97
src/mobile-pentesting/android-app-pentesting/smali-changes.md
View File

@ -1,52 +1,53 @@
# Smali - Decompiling/\[Modifying]/Compiling
# Smali - Decompilazione/[Modifica]/Compilazione
{{#include ../../banners/hacktricks-training.md}}
A volte è interessante modificare il codice dell'applicazione per accedere a informazioni nascoste per te (forse password o flag ben offuscati). Quindi, potrebbe essere interessante decompilare l'apk, modificare il codice e ricompilarlo.
**Riferimento agli Opcode:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
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.
## Modo Veloce
**Riferimento agli opcodes:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
Utilizzando **Visual Studio Code** e l'estensione [APKLab](https://github.com/APKLab/APKLab), puoi **decompilare automaticamente**, modificare, **ricompilare**, firmare e installare l'applicazione senza eseguire alcun comando.
## 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.
Un altro **script** che facilita molto questo compito è [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh)
## Decompilare l'APK
Utilizzando APKTool puoi accedere al **codice smali e alle risorse**:
Usando APKTool puoi accedere al **codice smali e alle risorse**:
```bash
apktool d APP.apk
```
Se **apktool** ti dà qualche errore, prova a [installare la **versione più recente**](https://ibotpeaches.github.io/Apktool/install/)
Se **apktool** ti dà un errore, prova[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/)
Alcuni **file interessanti da esaminare sono**:
Alcuni **file interessanti che dovresti esaminare** sono:
- _res/values/strings.xml_ (e tutti gli xml all'interno di res/values/\*)
- _res/values/strings.xml_ (and all xmls inside res/values/*)
- _AndroidManifest.xml_
- Qualsiasi file con estensione _.sqlite_ o _.db_
- Any file with extension _.sqlite_ or _.db_
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) o prova a usare l'argomento **`-r`** (Non decodificare le risorse). Poi, se il problema era in una risorsa e non nel codice sorgente, non avrai il problema (non decompilando nemmeno le risorse).
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).
## Modifica del codice smali
## Modificare il codice smali
Puoi **cambiare** **istruzioni**, cambiare il **valore** di alcune variabili o **aggiungere** nuove istruzioni. Modifico il codice Smali usando [**VS Code**](https://code.visualstudio.com), quindi installa l'**estensione smalise** e l'editor ti dirà se qualche **istruzione è errata**.\
Alcuni **esempi** possono essere trovati qui:
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:
- [Esempi di modifiche Smali](smali-changes.md)
- [Smali changes examples](smali-changes.md)
- [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md)
Oppure puoi [**controllare qui sotto alcune modifiche Smali spiegate**](smali-changes.md#modifying-smali).
Or you can [**check below some Smali changes explained**](smali-changes.md#modifying-smali).
## Ricompila l'APK
## Ricompilare l'APK
Dopo aver modificato il codice, puoi **ricompilare** il codice usando:
Dopo aver modificato il codice puoi **ricompilare** l'APK usando:
```bash
apktool b . #In the folder generated when you decompiled the application
```
Compilerà il nuovo APK all'interno della cartella _**dist**_.
Questo **compilerà** il nuovo APK **all'interno** della cartella _**dist**_.
Se **apktool** genera un **errore**, prova a [installare l'**ultima versione**](https://ibotpeaches.github.io/Apktool/install/)
Se **apktool** genera un **errore**, prova[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/)
### **Firma il nuovo APK**
@ -58,7 +59,7 @@ Infine, **firma** il nuovo APK:
```bash
jarsigner -keystore key.jks path/to/dist/* <your-alias>
```
### Ottimizza nuova applicazione
### Ottimizza 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).
```bash
@ -67,7 +68,7 @@ zipalign -v 4 infile.apk
```
### **Firma il nuovo APK (di nuovo?)**
Se **preferisci** utilizzare [**apksigner**](https://developer.android.com/studio/command-line/) invece di jarsigner, **dovresti firmare l'apk** dopo aver applicato **l'ottimizzazione con** zipalign. MA FAI ATTENZIONE CHE DEVI **FIRMARE L'APPLICAZIONE UNA SOLA VOLTA** CON jarsigner (prima di zipalign) O CON aspsigner (dopo zipalign).
Se **preferisci** usare [**apksigner**](https://developer.android.com/studio/command-line/) invece di jarsigner, **dovresti firmare l'apk** dopo aver applicato **l'ottimizzazione con** zipaling. MA NOTA CHE DEVI **FIRMARE L'APPLICAZIONE UNA SOLA VOLTA** CON jarsigner (prima di zipalign) O CON aspsigner (dopo zipaling).
```bash
apksigner sign --ks key.jks ./dist/mycompiled.apk
```
@ -89,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
return-void
.end method
```
Il set di istruzioni Smali è disponibile [qui](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions).
L'insieme di istruzioni Smali è disponibile [here](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 utilizzando l'opcode _const_, puoi modificare i loro valori, oppure puoi definirne di nuovi:
Alcune variabili sono definite all'inizio della funzione usando l'opcode _const_; puoi modificare i loro valori oppure puoi definirne di nuove:
```bash
#Number
const v9, 0xf4240
@ -126,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
### Cambiamenti maggiori
### Registrazione
### Logging
```bash
#Log win: <number>
iget v5, p0, Lcom/google/ctf/shallweplayagame/GameActivity;->o:I #Get this.o inside v5
@ -139,17 +140,17 @@ invoke-static {v5, v1}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/Strin
```
Raccomandazioni:
- Se intendi utilizzare variabili dichiarate all'interno della funzione (dichiarate v0,v1,v2...) inserisci queste righe tra il _.local \<numero>_ e le dichiarazioni delle variabili (_const v0, 0x1_)
- 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 delle variabili già dichiarate (in questo esempio dovrebbero essere _v10_ e _v11_, ricorda che inizia da v0).
- Se intendi usare variabili dichiarate all'interno della funzione (dichiarate v0,v1,v2...) inserisci queste righe tra _.local <number>_ 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_.
### Toasting
Ricorda di aggiungere 3 al numero di _.locals_ all'inizio della funzione.
Questo codice è preparato per essere inserito nel **mezzo di una funzione** (**cambia** il numero delle **variabili** come necessario). Prenderà il **valore di this.o**, **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** secondo necessità). 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
@ -161,4 +162,38 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/
move-result-object v12
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 (<clinit>):
```smali
.class public Lcom/example/App;
.super Landroid/app/Application;
.method static constructor <clinit>()V
.registers 1
const-string v0, "sotap" # library name without lib...so prefix
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:
```smali
.method public onCreate()V
.locals 1
const-string v0, "sotap"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
invoke-super {p0}, Landroid/app/Application;->onCreate()V
return-void
.end method
```
Note:
- Assicurati che la variante ABI corretta della libreria esista sotto lib/<abi>/ (ad es., arm64-v8a/armeabi-v7a) per evitare UnsatisfiedLinkError.
- Il caricamento molto precoce (class static initializer) garantisce che il native logger possa osservare l'attività JNI successiva.
## Riferimenti
- SoTap: logger leggero in-app per il comportamento di JNI (.so) – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}}