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/mobile-pentesting/android-app-pentesting/smali-changes.

Browse Source
This commit is contained in:
Translator 2025-09-04 02:41:08 +00:00
parent a0c3118bde
commit c9f8a22a7c
3 changed files with 219 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,4 +1,4 @@
# Malware Analise
# Malware-analise
{{#include ../../banners/hacktricks-training.md}}
@ -14,7 +14,7 @@
- [Intezer](https://analyze.intezer.com)
- [Any.Run](https://any.run/)
## Aflyn Antivirus en Opsporing Gereedskap
## Aflyn antivirus- en opsporingshulpmiddels
### Yara
@ -24,21 +24,21 @@ sudo apt-get install -y yara
```
#### Berei reëls voor
Gebruik hierdie skrif om al die yara malware reëls van github af te laai en te kombineer: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Skep die _**reëls**_ gids en voer dit uit. Dit sal 'n lêer genaamd _**malware_rules.yar**_ skep wat al die yara reëls vir malware bevat.
Gebruik hierdie script om al die yara-reëls vir malware van github af te laai en saam te voeg: [https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9](https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9)\
Skep die _**rules**_ gids en voer dit uit. Dit sal 'n lêer met die naam _**malware_rules.yar**_ skep wat al die yara-reëls vir malware bevat.
```bash
wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
python malware_yara_rules.py
```
#### Skande
#### Skandering
```bash
yara -w malware_rules.yar image #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder
```
#### YaraGen: Kontroleer vir malware en Skep reëls
#### YaraGen: Kontroleer vir malware en skep reëls
Jy kan die hulpmiddel [**YaraGen**](https://github.com/Neo23x0/yarGen) gebruik om yara reëls uit 'n binêre te genereer. Kyk na hierdie tutorials: [**Deel 1**](https://www.nextron-systems.com/2015/02/16/write-simple-sound-yara-rules/), [**Deel 2**](https://www.nextron-systems.com/2015/10/17/how-to-write-simple-but-sound-yara-rules-part-2/), [**Deel 3**](https://www.nextron-systems.com/2016/04/15/how-to-write-simple-but-sound-yara-rules-part-3/)
Jy kan die gereedskap [**YaraGen**](https://github.com/Neo23x0/yarGen) gebruik om yara rules van 'n binaêr te genereer. Kyk na hierdie handleidings: [**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/
@ -49,7 +49,7 @@ python3.exe yarGen.py --excludegood -m ../../mals/
```
sudo apt-get install -y clamav
```
#### Skande
#### Skandering
```bash
sudo freshclam #Update rules
clamscan filepath #Scan 1 file
@ -57,26 +57,26 @@ clamscan folderpath #Scan the whole folder
```
### [Capa](https://github.com/mandiant/capa)
**Capa** detecteer potensieel kwaadwillige **vermoëns** in uitvoerbare lêers: PE, ELF, .NET. Dit sal dinge vind soos Att\&ck taktieke, of verdagte vermoëns soos:
**Capa** detecteer potensieel kwaadwillige **capabilities** in uitvoerbare lêers: PE, ELF, .NET. Dit sal dus dinge soos Att\&ck tactics vind, of verdagte capabilities soos:
- kontroleer vir OutputDebugString fout
- loop as 'n diens
- skep proses
- check for OutputDebugString error
- run as a service
- create process
Kry dit in die [**Github repo**](https://github.com/mandiant/capa).
Get it int he [**Github repo**](https://github.com/mandiant/capa).
### IOCs
IOC beteken Indicator Of Compromise. 'n IOC is 'n stel **voorwaardes wat** sommige potensieel ongewenste sagteware of bevestigde **malware** identifiseer. Blue Teams gebruik hierdie soort definisie om **te soek na hierdie soort kwaadwillige lêers** in hul **stelsels** en **netwerke**.\
Om hierdie definisies te deel is baie nuttig, aangesien wanneer malware in 'n rekenaar geïdentifiseer word en 'n IOC vir daardie malware geskep word, ander Blue Teams dit kan gebruik om die malware vinniger te identifiseer.
IOC means Indicator Of Compromise. 'n IOC is 'n stel **conditions that identify** sekere moontlik ongewenste sagteware of bevestigde **malware**. Blue Teams gebruik hierdie soort definisie om **soortgelyke kwaadaardige lêers in hul stelsels en netwerke te soek**.\
Om hierdie definisies te deel is baie nuttig, want wanneer malware in 'n rekenaar geïdentifiseer word en 'n IOC vir daardie malware geskep word, kan ander Blue Teams dit gebruik om die malware vinniger te identifiseer.
'n Gereedskap om IOCs te skep of te wysig is [**IOC Editor**](https://www.fireeye.com/services/freeware/ioc-editor.html)**.**\
Jy kan gereedskap soos [**Redline**](https://www.fireeye.com/services/freeware/redline.html) gebruik om **te soek na gedefinieerde IOCs in 'n toestel**.
Jy kan gereedskap soos [**Redline**](https://www.fireeye.com/services/freeware/redline.html) gebruik om **naar gedefinieerde IOCs op 'n toestel te soek**.
### Loki
[**Loki**](https://github.com/Neo23x0/Loki) is 'n skandeerder vir Eenvoudige Indicators of Compromise.\
Detectie is gebaseer op vier detectiemetodes:
[**Loki**](https://github.com/Neo23x0/Loki) is 'n scanner vir Simple Indicators of Compromise.\
Opsporing is gebaseer op vier opsporingsmetodes:
```
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/) is 'n malware skandeerder vir Linux wat vrygestel is onder die GNU GPLv2 lisensie, wat ontwerp is rondom die bedreigings wat in gedeelde gasheeromgewings voorkom. Dit gebruik bedreigingsdata van netwerkrand indringingsdeteksiesisteme om malware wat aktief in aanvalle gebruik word, te onttrek en genereer handtekeninge vir opsporing. Daarbenewens word bedreigingsdata ook afgelei van gebruikersindienings met die LMD afrekenfunksie en malware gemeenskapsbronne.
[**Linux Malware Detect (LMD)**](https://www.rfxn.com/projects/linux-malware-detect/) is 'n malware-skandeerder vir Linux, vrygestel onder die GNU GPLv2-lisensie, wat ontwerp is rondom die bedreigings wat in gedeelde gehuisveste omgewings voorkom. Dit gebruik bedreigingsdata van network edge intrusion detection systems om malware wat aktief in aanvalle gebruik word te onttrek en signatures vir deteksie te genereer. Daarbenewens word bedreigingsdata ook verkry uit gebruikersinskrywings via die LMD checkout-feature en uit malware-gemeenskapsbronne.
### rkhunter
Gereedskap soos [**rkhunter**](http://rkhunter.sourceforge.net) kan gebruik word om die lêerstelsel na moontlike **rootkits** en malware te kontroleer.
Gereedskap soos [**rkhunter**](http://rkhunter.sourceforge.net) kan gebruik word om die lêerstelsel te kontroleer vir moontlike **rootkits** en malware.
```bash
sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]
```
### FLOSS
[**FLOSS**](https://github.com/mandiant/flare-floss) is 'n hulpmiddel wat sal probeer om obfuskeerde stringe binne uitvoerbare lêers te vind deur verskillende tegnieke te gebruik.
[**FLOSS**](https://github.com/mandiant/flare-floss) is 'n instrument wat probeer om geobfuskiseerde stringe binne uitvoerbare lêers te vind met verskeie tegnieke.
### PEpper
[PEpper ](https://github.com/Th3Hurrican3/PEpper)kontroleer 'n paar basiese goed binne die uitvoerbare lêer (binarie data, entropie, URL's en IP's, 'n paar yara reëls).
[PEpper ](https://github.com/Th3Hurrican3/PEpper)kontroleer 'n paar basiese dinge in die uitvoerbare lêer (binaire data, entropie, URLs en IP-adresse, sommige yara-reëls).
### PEstudio
[PEstudio](https://www.winitor.com/download) is 'n hulpmiddel wat inligting van Windows uitvoerbare lêers soos invoere, uitvoere, koptekste verkry, maar sal ook virus total kontroleer en potensiële Att\&ck tegnieke vind.
[PEstudio](https://www.winitor.com/download) is 'n instrument wat inligting oor Windows-uitvoerbare lêers verskaf, soos imports, exports en headers, en sal ook VirusTotal nagaan en potensiële Att\&ck-tegnieke vind.
### Detect It Easy(DiE)
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) is 'n hulpmiddel om te detecteer of 'n lêer **geënkripteer** is en ook **packers** te vind.
[**DiE**](https://github.com/horsicq/Detect-It-Easy/) is 'n instrument om te bepaal of 'n lêer **versleuteld** is en om ook **packers** te vind.
### NeoPI
[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is 'n Python-skrip wat 'n verskeidenheid **statistiese metodes** gebruik om **obfuskeerde** en **geënkripteerde** inhoud binne teks/skrip lêers te detecteer. Die beoogde doel van NeoPI is om te help met die **detectie van verborge web shell kode**.
[**NeoPI** ](https://github.com/CiscoCXSecurity/NeoPI)is 'n Python-skrip wat 'n verskeidenheid **statistiese metodes** gebruik om **geobfuskiseerde** en **versleutelde** inhoud binne teks-/skriplêers te identifiseer. Die beoogde doel van NeoPI is om te help met die **identifisering van verborge web shell-kode**.
### **php-malware-finder**
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) doen sy beste om **obfuskeerde**/**verdagte kode** sowel as lêers wat **PHP** funksies gebruik wat dikwels in **malwares**/webshells gebruik word, te detecteer.
[**PHP-malware-finder**](https://github.com/nbs-system/php-malware-finder) doen sy uiterste bes om **geobfuskiseerde**/**verdagte kode** te identifiseer, asook lêers wat **PHP**-funksies gebruik wat dikwels in **malware**/webshells aangetref word.
### Apple Binary Signatures
Wanneer jy 'n paar **malware monsters** kontroleer, moet jy altyd die **handtekening** van die binêre lêer **kontroleer** aangesien die **ontwikkelaar** wat dit onderteken het, dalk reeds **verbonde** is met **malware.**
Wanneer jy 'n **malware sample** nagaan, moet jy altyd die **handtekening** van die binêr **kontroleer**, aangesien die **ontwikkelaar** wat dit geteken het moontlik reeds **verwant** is aan **malware.**
```bash
#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"
@ -137,29 +137,53 @@ codesign --verify --verbose /Applications/Safari.app
#Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app
```
## Ontdekkings Tegnieke
## Detection Techniques
### Lêer Stapeling
### File Stacking
As jy weet dat 'n sekere gids wat die **lêers** van 'n webbediener bevat, **laas op 'n sekere datum opgedateer is**. **Kontroleer** die **datum** waarop al die **lêers** in die **webbediener geskep en gewysig** is, en as enige datum **verdag** is, kontroleer daardie lêer.
If you know that some folder containing the **files** of a web server was **last updated on some date**. **Check** the **date** all the **files** in the **web server were created and modified** and if any date is **suspicious**, check that file.
As jy weet dat 'n vouer wat die **lêers** van 'n **web server** bevat **laas bygewerk is op 'n bepaalde datum**, **kontroleer** die **datum** waarop al die **lêers** in die **web server** geskep en gewysig is; as enige datum **verdag** is, ondersoek daardie lêer.
### Baselines
As die lêers van 'n gids **nie gewysig moes gewees het nie**, kan jy die **hash** van die **oorspronklike lêers** van die gids bereken en dit met die **huidige** vergelyk. Enige iets wat gewysig is, sal **verdag** wees.
If the files of a folder **shouldn't have been modified**, you can calculate the **hash** of the **original files** of the folder and **compare** them with the **current** ones. Anything modified will be **suspicious**.
### Statistiese Analise
As die **lêers** van 'n vouer **nie gewysig moes gewees het nie**, kan jy die **hash** van die ** oorspronklike lêers ** van die vouer bereken en dit met die **huidige** vergelyk. Alles wat gewysig is, sal **verdag** wees.
Wanneer die inligting in logs gestoor word, kan jy **statistieke kontroleer soos hoeveel keer elke lêer van 'n webbediener toeganklik was, aangesien 'n web shell een van die mees** mag wees.
### Statistical Analysis
When the information is saved in logs you can **check statistics like how many times each file of a web server was accessed as a web shell might be one of the most**.
Wanneer die inligting in logs gestoor word, kan jy **statistieke nagaan**, byvoorbeeld hoe dikwels elke lêer van 'n web server geraadpleeg is — 'n web shell kan een van die mees-toeganklike wees.
---
## Deobfuskerende Dinamiese Beheer-Stroom (JMP/CALL RAX Verspreiders)
### Android in-app native telemetry (no root)
Moderne malware-families misbruik sterk Beheer-Stroom Grafiek (CFG) obfuskerings: in plaas van 'n direkte sprong/oproep bereken hulle die bestemming tydens uitvoering en voer 'n `jmp rax` of `call rax` uit. 'n Klein *verspreider* (tipies nege instruksies) stel die finale teiken op grond van die CPU `ZF`/`CF` vlae, wat statiese CFG-herwinning heeltemal breek.
On Android, you can instrument native code inside the target app process by preloading a tiny logger library before other JNI libs initialize. This gives early visibility into native behavior without system-wide hooks or root. A popular approach is SoTap: drop libsotap.so for the right ABI into the APK and inject a System.loadLibrary("sotap") call early (e.g., static initializer or Application.onCreate), then collect logs from internal/external paths or Logcat fallback.
Die tegniek – wat deur die SLOW#TEMPEST laaier gedemonstreer word – kan oorwin word met 'n drie-stap werkvloei wat slegs op IDAPython en die Unicorn CPU-emulator staatmaak.
Op Android kan jy native code binne die teiken-app-proses instrumenteer deur 'n klein logger-biblioteek vooraf te laai voordat ander JNI-libs inisieer. Dit gee vroeë sigbaarheid in native gedrag sonder stelsel-wyde hooks of root. 'n Populêre benadering is SoTap: plaas libsotap.so vir die regte ABI in die APK en injekteer vroeg 'n System.loadLibrary("sotap") oproep (bv. static initializer of Application.onCreate), en versamel dan logs vanaf interne/eksterne paaie of Logcat as rugsteun.
### 1. Vind elke indirekte sprong / oproep
See the Android native reversing page for setup details and log paths:
{{#ref}}
../../../mobile-pentesting/android-app-pentesting/reversing-native-libraries.md
{{#endref}}
---
## Deobfuscating Dynamic Control-Flow (JMP/CALL RAX Dispatchers)
Modern malware families heavily abuse Control-Flow Graph (CFG) obfuscation: instead of a direct jump/call they compute the destination at run-time and execute a `jmp rax` or `call rax`. A small *dispatcher* (typically nine instructions) sets the final target depending on the CPU `ZF`/`CF` flags, completely breaking static CFG recovery.
Moderne malware-families misbruik Control-Flow Graph (CFG)-obfuskering in sterk mate: in plaas van 'n direkte jump/call bereken hulle die bestemming tydens uitvoering en voer 'n `jmp rax` of `call rax` uit. 'n Klein *dispatcher* (tipies nege instruksies) stel die finale teiken afhangend van die CPU `ZF`/`CF` vlagte, wat statiese CFG-herwinning heeltemal breek.
The technique – showcased by the SLOW#TEMPEST loader – can be defeated with a three-step workflow that only relies on IDAPython and the Unicorn CPU emulator.
Die tegniek — tentoongestel deur die SLOW#TEMPEST loader — kan gekeer word met 'n drie-stap werkvloei wat slegs staatmaak op IDAPython en die Unicorn CPU emulator.
### 1. Locate every indirect jump / call
```python
import idautils, idc
@ -168,7 +192,7 @@ mnem = idc.print_insn_mnem(ea)
if mnem in ("jmp", "call") and idc.print_operand(ea, 0) == "rax":
print(f"[+] Dispatcher found @ {ea:X}")
```
### 2. Trek die dispatcher byte-kode uit
### 2. Haal die dispatcher byte-code uit
```python
import idc
@ -199,9 +223,9 @@ mu.reg_write(UC_X86_REG_RAX, 0)
mu.emu_start(BASE, BASE+len(code))
return mu.reg_read(UC_X86_REG_RAX)
```
Voer `run(code,0,0)` en `run(code,1,1)` uit om die *vals* en *waar* takteikens te verkry.
Voer `run(code,0,0)` en `run(code,1,1)` uit om die *false* en *true* takbestemmings te kry.
### 4. Patches 'n direkte sprong / oproep terug
### 4. Patch terug 'n direkte jump / call
```python
import struct, ida_bytes
@ -210,27 +234,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))
```
Na die opknapping, dwing IDA om die funksie weer te analiseer sodat die volle CFG en Hex-Rays-uitvoer herstel word:
Na patching, dwing IDA om die funksie opnuut te analiseer sodat die volledige CFG en Hex-Rays-uitset herstel word:
```python
import ida_auto, idaapi
idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))
```
### 5. Etikette indirekte API-oproepe
### 5. Merk indirekte API-aanroepe
Sodra die werklike bestemming van elke `call rax` bekend is, kan jy vir IDA sê wat dit is sodat parameter tipes & veranderlike name outomaties herstel word:
Sodra die werklike bestemming van elke `call rax` bekend is, kan jy IDA vertel wat dit is sodat parametertipes en veranderlike name outomaties herstel word:
```python
idc.set_callee_name(call_ea, resolved_addr, 0) # IDA 8.3+
```
### Praktiese voordele
* Herstel die werklike CFG → dekompilering gaan van *10* lyne na duisende.
* Maak string-kruisverwysing & xrefs moontlik, wat gedragheropbou triviaal maak.
* Skripte is herbruikbaar: gooi hulle in enige laaier wat deur dieselfde truuk beskerm word.
* Herstel die werklike CFG → dekompilasie gaan van *10* reëls na duisende.
* Laat string-cross-reference & xrefs toe, wat gedragsherbou triviaal maak.
* Skripte is herbruikbaar: plaas hulle in enige loader wat deur dieselfde truuk beskerm word.
---
## Verwysings
- [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}}

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

@ -1,47 +1,50 @@
# Reversing Native Libraries
# Omkeer-engineering van Native Biblioteke
{{#include ../../banners/hacktricks-training.md}}
**Vir verdere inligting, kyk:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
Android-toepassings kan inheemse biblioteke gebruik, wat tipies in C of C++ geskryf is, vir prestasiekritieke take. Malware-skeppers misbruik ook hierdie biblioteke omdat ELF gedeelde voorwerpe steeds moeiliker is om te dekompileer as DEX/OAT byte-kode. Hierdie bladsy fokus op *praktiese* werksvloeie en *onlangse* hulpmiddelverbeterings (2023-2025) wat die omkering van Android `.so` lêers makliker maak.
**Vir meer inligting sien:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html)
Android-apps kan native biblioteke gebruik, gewoonlik geskryf in C of C++, vir prestasie-kritieke take. Malware-makers misbruik ook hierdie biblioteke omdat ELF shared objects steeds moeiliker is om te dekompileer as DEX/OAT byte-code.
Hierdie bladsy fokus op *praktiese* werkvloei en *onlangse* tooling improvements (2023-2025) wat die omkeer van Android `.so`-lêers makliker maak.
---
### Vinnige triage-werksvloei vir 'n vars getrokke `libfoo.so`
### Vinnige triage-werkvloei vir 'n pas onttrekte `libfoo.so`
1. **Onthaal die biblioteek**
1. **Haal die biblioteek uit**
```bash
# Van 'n geïnstalleerde toepassing
# From an installed application
adb shell "run-as <pkg> cat lib/arm64-v8a/libfoo.so" > libfoo.so
# Of van die APK (zip)
# Or from the APK (zip)
unzip -j target.apk "lib/*/libfoo.so" -d extracted_libs/
```
2. **Identifiseer argitektuur & beskermings**
```bash
file libfoo.so # arm64 of arm32 / x86
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, ens.
file libfoo.so # arm64 or arm32 / x86
readelf -h libfoo.so # OS ABI, PIE, NX, RELRO, etc.
checksec --file libfoo.so # (peda/pwntools)
```
3. **Lys geëksporteerde simbole & JNI bindings**
3. **Lys uitgevoerde simbole & JNI-bindinge**
```bash
readelf -s libfoo.so | grep ' Java_' # dinamies-gekoppelde JNI
strings libfoo.so | grep -i "RegisterNatives" -n # staties-geregistreerde JNI
readelf -s libfoo.so | grep ' Java_' # dynamic-linked JNI
strings libfoo.so | grep -i "RegisterNatives" -n # static-registered JNI
```
4. **Laai in 'n dekompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper of Cutter/Rizin) en voer outomatiese analise uit. Nuwe Ghidra weergawes het 'n AArch64 dekompiler bekendgestel wat PAC/BTI stubs en MTE-tags herken, wat die analise van biblioteke wat met die Android 14 NDK gebou is, aansienlik verbeter.
5. **Bepaal op statiese vs dinamiese omkering:** gestript, obfuskeer kode benodig dikwels *instrumentasie* (Frida, ptrace/gdbserver, LLDB).
4. **Laai in 'n dekompiler** (Ghidra ≥ 11.0, IDA Pro, Binary Ninja, Hopper or Cutter/Rizin) en voer outo-analise uit.
Nuweer Ghidra-weergawes het 'n AArch64 decompiler ingesluit wat PAC/BTI stubs en MTE tags herken, wat die ontleding van biblioteke wat met die Android 14 NDK gebou is grootliks verbeter.
5. **Bepaal statiese vs dinamiese reversing:** stripped, obfuscated code often needs *instrumentation* (Frida, ptrace/gdbserver, LLDB).
---
### Dinamiese Instrumentasie (Frida ≥ 16)
### Dynamic Instrumentation (Frida ≥ 16)
Frida se 16-reeks het verskeie Android-spesifieke verbeterings gebring wat help wanneer die teiken moderne Clang/LLD optimaliseringe gebruik:
Frida’s 16-reeks het verskeie Android-spesifieke verbeterings gebring wat help wanneer die teiken moderne Clang/LLD optimisations gebruik:
* `thumb-relocator` kan nou *klein ARM/Thumb funksies* wat deur LLD se aggressiewe uitlijning (`--icf=all`) gegenereer is, *hook*.
* Die opnoem en herbinding van *ELF invoer slots* werk op Android, wat per-module `dlopen()`/`dlsym()` patching moontlik maak wanneer inline hooks verwerp word.
* Java hooking is reggestel vir die nuwe **ART vinnige toegangspunt** wat gebruik word wanneer toepassings gecompileer word met `--enable-optimizations` op Android 14.
* `thumb-relocator` can now *hook tiny ARM/Thumb functions* generated by LLD’s aggressive alignment (`--icf=all`).
* Enumerating and rebinding *ELF import slots* works on Android, enabling per-module `dlopen()`/`dlsym()` patching when inline hooks are rejected.
* Java hooking was fixed for the new **ART quick-entrypoint** used when apps are compiled with `--enable-optimizations` on Android 14.
Voorbeeld: opnoem van alle funksies wat deur `RegisterNatives` geregistreer is en hul adresse tydens uitvoering dump:
Example: enumerating all functions registered through `RegisterNatives` and dumping their addresses at 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 sal uit die boks werk op PAC/BTI-geaktiveerde toestelle (Pixel 8/Android 14+) solank jy frida-server 16.2 of later gebruik – vroeëre weergawes het gefaal om padding vir inline hooks te vind. citeturn5search2turn5search0
Frida sal uit die boks werk op PAC/BTI-enabled devices (Pixel 8/Android 14+) solank jy frida-server 16.2 of later gebruik – vroeëre weergawes kon nie padding vir inline hooks lokaliseer nie.
### Proses-lokale JNI-telemetrie via voorgelaaide .so (SoTap)
Wanneer volwaardige instrumentasie oorbodig of geblokkeer is, kan jy steeds native-vlak sigbaarheid kry deur ’n klein logger in die teikenproses voor te laai. SoTap is ’n liggewig Android native (.so) biblioteek wat die runtime-gedrag van ander JNI (.so) biblioteke binne dieselfde app-proses log (geen root benodig nie).
Belangrike eienskappe:
- Initialiseer vroeg en waarneem JNI/native-interaksies binne die proses wat dit laai.
- Bewaar logs deur verskeie skryfbare paaie met ’n elegante terugval na Logcat wanneer berging beperk is.
- Bron-aanpasbaar: wysig sotap.c om uit te brei of aan te pas wat gelog word en herbou per ABI.
Opstelling (repak die APK):
1) Plaas die regte ABI build in die APK sodat die loader libsotap.so kan oplos:
- lib/arm64-v8a/libsotap.so (for arm64)
- lib/armeabi-v7a/libsotap.so (for arm32)
2) Verseker dat SoTap laai voordat ander JNI-libs laai. Injiseer ’n vroeë oproep (bv. Application subclass static initializer of onCreate) sodat die logger eers geïnisialiseer word. Smali snippet example:
```smali
const-string v0, "sotap"
invoke-static {v0}, Ljava/lang/System;->loadLibrary(Ljava/lang/String;)V
```
3) Herbou/onderteken/installeer, hardloop die app, en versamel dan logs.
Log-paadjies (gekontroleer in volgorde):
```
/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
```
Aantekeninge en probleemoplossing:
- ABI-belyning is verpligtend. ’n ongelykheid sal UnsatisfiedLinkError veroorsaak en die logger sal nie laai nie.
- Stoorbeperkings is algemeen op moderne Android; as lêerskryf misluk, sal SoTap steeds via Logcat uitsend.
- Gedrag/uitvoerigheid is bedoel om aangepas te word; bou dit weer vanaf die bron nadat jy sotap.c geredigeer het.
Hierdie benadering is nuttig vir malware-triage en JNI-debugging waar dit kritiek is om native oproepvloei vanaf prosesbegin waar te neem, maar root/stelselwye hooks nie beskikbaar is nie.
---
### Onlangse kwesbaarhede wat die moeite werd is om in APK's te jag
### Onlangse kwesbaarhede wat die moeite werd is om in APKs te soek
| Jaar | CVE | Aangetaste biblioteek | Aantekeninge |
|------|-----|------------------|-------|
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow bereikbaar vanaf native kode wat WebP-prente decodeer. Verskeie Android-apps bundel kwesbare weergawes. Wanneer jy 'n `libwebp.so` binne 'n APK sien, kontroleer sy weergawe en probeer om te exploiteer of te patch.| citeturn2search0|
|2024|Meervoudig|OpenSSL 3.x reeks|Verskeie geheue-veilige en padding-orakel probleme. Baie Flutter & ReactNative bundels verskaf hul eie `libcrypto.so`.|
|------|-----|-----------------------|-------------|
|2023|CVE-2023-4863|`libwebp` ≤ 1.3.1|Heap buffer overflow bereikbaar vanaf native kode wat WebP-beelde dekodeer. Verskeie Android-apps bundel kwesbare weergawes. Wanneer jy `libwebp.so` binne 'n APK sien, kontroleer die weergawe en probeer eksploitasie of patches toepas.| |
|2024|Multiple|OpenSSL 3.x series|Verskeie geheue-veiligheids- en padding-orakel-kwessies. Baie Flutter & ReactNative-bundels stuur hul eie `libcrypto.so`.|
Wanneer jy *derdeparty* `.so` lêers binne 'n APK opmerk, kontroleer altyd hul hash teen opwaartse advies. SCA (Software Composition Analysis) is ongewoon op mobiele toestelle, so verouderde kwesbare boue is volop.
Wanneer jy *derdeparty* `.so` lêers binne 'n APK raak, kruisverifieer altyd hul hash teen upstream advisories. SCA (Software Composition Analysis) is ongewoon op mobiele platforms, dus is verouderde kwesbare boue algemeen.
---
### Anti-Reversing & Hardening neigings (Android 13-15)
### Anti-Reversing & Hardening trends (Android 13-15)
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 stel PAC/BTI in stelselbiblioteke op ondersteunde ARMv8.3+ silikoon in. Decompilers vertoon nou PAC-verwante pseudo-instruksies; vir dinamiese analise injecteer Frida trampolines *nadat* PAC verwyder is, maar jou eie trampolines moet `pacda`/`autibsp` aanroep waar nodig.
* **MTE & Scudo geharde allokator:** geheue-tagging is opt-in maar baie Play-Integrity bewuste apps bou met `-fsanitize=memtag`; gebruik `setprop arm64.memtag.dump 1` plus `adb shell am start ...` om tag foute te vang.
* **LLVM Obfuscator (opake predikate, kontrole-stroom afvlakking):** kommersiële packers (bv. Bangcle, SecNeo) beskerm toenemend *native* kode, nie net Java nie; verwag valse kontrole-stroom en versleutelde string blobs in `.rodata`.
* **Pointer Authentication (PAC) & Branch Target Identification (BTI):** Android 14 aktiveer PAC/BTI in stelselbiblioteke op ondersteunde ARMv8.3+ silikoon. Decompilers toon nou PAC-verwante pseudo-instruksies; vir dinamiese analise spuit Frida trampolines in ná die verwydering van PAC, maar jou eie trampolines behoort `pacda`/`autibsp` aan te roep waar nodig.
* **MTE & Scudo hardened allocator:** memory-tagging is opsioneel maar baie Play-Integrity-bewuste apps bou met `-fsanitize=memtag`; gebruik `setprop arm64.memtag.dump 1` plus `adb shell am start ...` om tag-foute vas te vang.
* **LLVM Obfuscator (opaque predicates, control-flow flattening):** kommersiële packers (e.g., Bangcle, SecNeo) beskerm toenemend *native* kode, nie net Java nie; verwag valsige control-flow en versleutelde string blobs in `.rodata`.
---
### Hulpbronne
- **Leer ARM Assembly:** [Azeria Labs – ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/)
- **JNI & NDK Dokumentasie:** [Oracle JNI Spec](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) · [Android JNI Wenke](https://developer.android.com/training/articles/perf-jni) · [NDK Gidse](https://developer.android.com/ndk/guides/)
- **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)
### Verwysings
- Frida 16.x verandering-log (Android hooking, tiny-function herlokasie) – [frida.re/news](https://frida.re/news/) citeturn5search0
- NVD advies vir `libwebp` overflow 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/)
- NVD advisory for `libwebp` overflow 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}}

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

@ -1,79 +1,80 @@
# Smali - Decompiling/\[Modifying]/Compiling
# Smali - Decompiling/[Modifying]/Compiling
{{#include ../../banners/hacktricks-training.md}}
Soms is dit interessant om die toepassingskode te wysig om toegang te verkry tot verborge inligting vir jou (miskien goed obfuskeerde wagwoorde of vlae). Dan kan dit interessant wees om die apk te dekompileer, die kode te wysig en dit weer te compileer.
**Opcodes verwysing:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
Soms is dit interessant om die toepassing se code te wysig om toegang tot versteekte inligting te kry (miskien goed obfuscated passwords of flags). Dan kan dit interessant wees om die apk te decompileer, die code te wysig en dit weer te recompileer.
## Vinninge Weg
**Opcodes reference:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html)
Met **Visual Studio Code** en die [APKLab](https://github.com/APKLab/APKLab) uitbreiding, kan jy **outomaties dekompileer**, wysig, **hercompileer**, teken & installeer die toepassing sonder om enige opdrag uit te voer.
## Fast Way
Nog 'n **script** wat hierdie taak baie vergemaklik, is [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh)
Deur **Visual Studio Code** en die [APKLab](https://github.com/APKLab/APKLab) extension te gebruik, kan jy die toepassing **automatically decompile**, modify, **recompile**, sign & install sonder om enige opdrag uit te voer.
## Dekompileer die APK
Nog 'n **script** wat hierdie taak baie vergemaklik is [**https://github.com/ax/apk.sh**](https://github.com/ax/apk.sh)
Met APKTool kan jy toegang verkry tot die **smali kode en hulpbronne**:
## Decompile the APK
Deur APKTool te gebruik kan jy toegang kry tot die **smali code and resources**:
```bash
apktool d APP.apk
```
As **apktool** jou enige fout gee, probeer[ die **nuutste weergawe**](https://ibotpeaches.github.io/Apktool/install/)
As **apktool** enige fout gee, try[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/)
Sommige **interessante lêers wat jy moet kyk is**:
Sommige **interessante lêers waarna jy moet kyk**:
- _res/values/strings.xml_ (en alle xmls binne res/values/\*)
- _res/values/strings.xml_ (and all xmls inside res/values/*)
- _AndroidManifest.xml_
- Enige lêer met die uitbreiding _.sqlite_ of _.db_
- Any file with extension _.sqlite_ or _.db_
As `apktool` **probleme het om die toepassing te dekodeer**, kyk na [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) of probeer om die argument **`-r`** te gebruik (Moet nie hulpbronne dekodeer nie). Dan, as die probleem in 'n hulpbron was en nie in die bronkode nie, sal jy nie die probleem hê nie (jy sal ook nie die hulpbronne dekompileer nie).
As `apktool` **probleme het om die toepassing te decodeer** kyk na [https://ibotpeaches.github.io/Apktool/documentation/#framework-files](https://ibotpeaches.github.io/Apktool/documentation/#framework-files) of probeer die argument **`-r`** gebruik (Moet nie die resources decodeer nie). Dan, as die probleem in 'n resource en nie in die bronkode was nie, sal jy nie die probleem hê nie (jy sal ook nie die resources dekompileer nie).
## Verander smali kode
Jy kan **verander** **instruksies**, die **waarde** van sommige veranderlikes verander of **nuwe** instruksies byvoeg. Ek verander die Smali kode met behulp van [**VS Code**](https://code.visualstudio.com), jy installeer dan die **smalise uitbreiding** en die redigeerder sal jou vertel of enige **instruksie verkeerd is**.\
Jy kan **instruksies** verander, die **waarde** van sekere veranderlikes verander of nuwe instruksies **byvoeg**. Ek verander die Smali kode met behulp van [**VS Code**](https://code.visualstudio.com), installeer dan die **smalise extension** en die redigeerder sal vir jou sê as enige **instruksie verkeerd is**.\
Sommige **voorbeelde** kan hier gevind word:
- [Smali changes examples](smali-changes.md)
- [Google CTF 2018 - Shall We Play a Game?](google-ctf-2018-shall-we-play-a-game.md)
Of jy kan [**onder kyk na sommige Smali veranderinge verduidelik**](smali-changes.md#modifying-smali).
Or you can [**check below some Smali changes explained**](smali-changes.md#modifying-smali).
## Hernoem die APK
## Herkompileer die APK
Na die aanpassing van die kode kan jy die kode **hernoem** met:
Na die wysiging van die kode kan jy die kode **herkompileer** met:
```bash
apktool b . #In the folder generated when you decompiled the application
```
Dit sal die nuwe APK **compile** **binne** die _**dist**_ gids.
Dit sal die nuwe APK **compile** **inside** die _**dist**_ gids.
As **apktool** 'n **fout** gooi, probeer[ om die **nuutste weergawe**](https://ibotpeaches.github.io/Apktool/install/) te installeer.
As **apktool** 'n **error** gooi, probeer[ installing the **latest version**](https://ibotpeaches.github.io/Apktool/install/)
### **Teken die nuwe APK**
### **Sign the new APK**
Dan moet jy 'n **sleutel** **genereer** (jy sal gevra word vir 'n wagwoord en vir 'n paar inligting wat jy lukraak kan invul):
Dan moet jy **generate a key** (jy sal gevra word vir 'n password en vir sekere inligting wat jy lukraak kan invul):
```bash
keytool -genkey -v -keystore key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias <your-alias>
```
Laastens, **teken** die nuwe APK:
Laastens, **onderteken** die nuwe APK:
```bash
jarsigner -keystore key.jks path/to/dist/* <your-alias>
```
### Optimaliseer nuwe aansoek
### Optimaliseer nuwe toepassing
**zipalign** is 'n argief-uitlyn hulpmiddel wat belangrike optimalisering aan Android aansoek (APK) lêers bied. [More information here](https://developer.android.com/studio/command-line/zipalign).
**zipalign** is 'n argief-belyningshulpmiddel wat belangrike optimalisering vir Android-toepassings (APK)-lêers verskaf. [Meer inligting hier](https://developer.android.com/studio/command-line/zipalign).
```bash
zipalign [-f] [-v] <alignment> infile.apk outfile.apk
zipalign -v 4 infile.apk
```
### **Teken die nuwe APK (weer?)**
### **Onderteken die nuwe APK (weer?)**
As jy **verkies** om [**apksigner**](https://developer.android.com/studio/command-line/) te gebruik in plaas van jarsigner, **moet jy die apk teken** nadat jy **die optimalisering met** zipalign toegepas het. MAAR LET OP DAT JY SLEGS DIE AANSOEK EEN KEER MOET **TEKEN MET** jarsigner (voor zipalign) OF MET aspsigner (na zipalign).
As jy **verkies** om [**apksigner**](https://developer.android.com/studio/command-line/) te gebruik in plaas van jarsigner, **moet jy die APK onderteken** na die toepassing van **die optimalisering met** zipaling. MAAR LET OP DAT JY NET DIE **TOEPASSING EENMALIG MOET ONDERTEKEN** MET jarsigner (voor zipalign) OF MET aspsigner (na zipaling).
```bash
apksigner sign --ks key.jks ./dist/mycompiled.apk
```
## Modifying Smali
## Wysig Smali
Vir die volgende Hello World Java kode:
Vir die volgende Hello World Java code:
```java
public static void printHelloWorld() {
System.out.println("Hello World")
@ -89,13 +90,13 @@ invoke-virtual {v0,v1}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
return-void
.end method
```
Die Smali instruksieset is beskikbaar [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions).
Die Smali-instruksieset is beskikbaar [here](https://source.android.com/devices/tech/dalvik/dalvik-bytecode#instructions).
### Ligte Veranderinge
### Verander aanvanklike waardes van 'n veranderlike binne 'n funksie
### Wysig die aanvanklike waardes van 'n veranderlike binne 'n funksie
Sommige veranderlikes word aan die begin van die funksie gedefinieer met die opcode _const_, jy kan sy waardes verander, of jy kan nuwe eenhede definieer:
Sommige veranderlikes word aan die begin van die funksie gedefinieer met behulp van die opcode _const_, jy kan die waardes daarvan wysig, of jy kan nuwe veranderlikes definieer:
```bash
#Number
const v9, 0xf4240
@ -128,7 +129,7 @@ goto :goto_6 #Always go to: :goto_6
```
### Groter Veranderinge
### Teken
### Logregistrasie
```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
```
Aanbevelings:
- As jy verklaarde veranderlikes binne die funksie gaan gebruik (verklaarde v0,v1,v2...) plaas hierdie lyne tussen die _.local \<number>_ en die verklarings van die veranderlikes (_const v0, 0x1_)
- As jy die logging kode in die middel van die kode van 'n funksie wil plaas:
- Voeg 2 by die aantal verklaarde veranderlikes: Byvoorbeeld: van _.locals 10_ na _.locals 12_
- Die nuwe veranderlikes moet die volgende nommers van die reeds verklaarde veranderlikes wees (in hierdie voorbeeld moet dit _v10_ en _v11_ wees, onthou dat dit begin by v0).
- Verander die kode van die logging funksie en gebruik _v10_ en _v11_ in plaas van _v5_ en _v1_.
- As jy verklaarde veranderlikes binne die funksie gaan gebruik (verklaarde v0,v1,v2...) plaas hierdie reëls tussen die _.local <number>_ en die deklarasies van die veranderlikes (_const v0, 0x1_)
- As jy die logging-kode in die middel van die kode van 'n funksie wil plaas:
- Voeg 2 by die aantal verklaarde veranderlikes: Ex: van _.locals 10_ na _.locals 12_
- Die nuwe veranderlikes moet die volgende nommers wees na die reeds verklaarde veranderlikes (in hierdie voorbeeld moet dit _v10_ en _v11_ wees, onthou dat dit by v0 begin).
- Verander die kode van die logging-funksie en gebruik _v10_ en _v11_ in plaas van _v5_ en _v1_.
### Toasting
Onthou om 3 by die aantal _.locals_ aan die begin van die funksie te voeg.
Hierdie kode is voorberei om in die **middel van 'n funksie** ingevoeg te word (**verander** die nommer van die **veranderlikes** soos nodig). Dit sal die **waarde van this.o** neem, **transformeer** dit na **String** en dan 'n **toast** met sy waarde **maak**.
Hierdie kode is voorberei om in die **middel van 'n funksie** ingevoeg te word (**verander** die aantal **veranderlikes** soos nodig). Dit sal die **waarde van this.o** neem, **omskakel** dit na **String** en dan **maak** 'n **toast** met daardie waarde.
```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
```
### Laai 'n natiewe biblioteek tydens opstart (System.loadLibrary)
Partykeer moet jy 'n natiewe biblioteek vooraf laai sodat dit geïnisialiseer word voor ander JNI-biblioteke (bv. om proses-lokale telemetrie/logging moontlik te maak). Jy kan 'n oproep na System.loadLibrary() injekteer in 'n statiese initialiseerder of vroeg in Application.onCreate(). Voorbeeld smali vir 'n statiese klas-initialiseerder (<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
```
Alternatiewelik, plaas dieselfde twee instruksies aan die begin van jou Application.onCreate() om te verseker dat die biblioteek so vroeg as moontlik laai:
```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
```
Aantekeninge:
- Maak seker die korrekte ABI-variant van die biblioteek bestaan onder lib/<abi>/ (bv. arm64-v8a/armeabi-v7a) om UnsatisfiedLinkError te voorkom.
- Deur baie vroeg te laai (class static initializer) verseker dat die native logger daaropvolgende JNI-aktiwiteit kan waarneem.
## Verwysings
- SoTap: Liggewig in-app JNI (.so) gedragslogger – [github.com/RezaArbabBot/SoTap](https://github.com/RezaArbabBot/SoTap)
{{#include ../../banners/hacktricks-training.md}}