Remote code execution in LangChain-ChatChat 0.3.1 allows unauthenticated remote attackers to execute arbitrary commands by injecting malicious commands into the MCP STDIO server configuration via the exposed management interface. When the MCP feature is enabled for agent execution, subsequent agent activity triggers the configured command, leading to full code execution in the service context. No active exploitation has been reported, and EPSS indicates a low probability of widespread attack.
SQL injection in Slah CMS v1.5.0 and below permits unauthenticated remote attackers to execute arbitrary SQL via the id parameter in vereador_ver.php, risking data breach and tampering. No active exploitation or public exploit is known, and EPSS indicates a 0.03% probability of exploitation.
Uncontrolled search path vulnerability in Adobe Photoshop Installer allows a low-privileged local attacker to execute arbitrary code in the context of the current user. Exploitation requires the user to run the installer from a location where the attacker has planted malicious dependencies. No active exploitation or public exploit code has been identified, and the EPSS chance of exploitation is extremely low (0.01%).
Blind SQL injection in Beaver Builder WordPress plugin (≤2.10.1.2) allows authenticated attackers with low‑privilege access to extract arbitrary database contents via crafted parameters. The vulnerability has a CVSS score of 8.5, but EPSS indicates a very low exploitation probability (0.02%); no public exploit or active exploitation is known.
Local privilege escalation in Barracuda RMM (all versions prior to 2025.2.2) enables authenticated Windows users to execute arbitrary code as NT AUTHORITY\SYSTEM by writing malicious files to the insecurely-permissioned C:\Windows\Automation directory. Vendor-released patch version 2025.2.2 addresses the filesystem ACL misconfiguration. EPSS data unavailable; no confirmed active exploitation (not in CISA KEV), though VulnCheck public advisory increases likelihood of POC development. CVSS 8.5 reflects high local impact requiring only low-privileged authentication.
Local privilege escalation in Lenovo Software Fix versions prior to 7.5.5.19 allows an authenticated local attacker to execute arbitrary code with elevated privileges via argument injection. While the CVSS 4.0 score is 8.5, exploitation requires local authenticated access and no active exploitation or public exploit is known; EPSS probability is extremely low (0.01%).
Command injection in the connect function in NietThijmen ShoppingCart 0.0.2 allows an attacker to execute arbitrary shell commands and achieve remote code execution via injection of malicious. Rated high severity (CVSS 8.4), this vulnerability is no authentication required, low attack complexity. No vendor patch available.
Incorrect authorization in SailPoint IdentityIQ 8.4 and 8.5 allows authenticated users with the Debug Pages Read Only capability (or any custom capability containing ViewAccessDebugPage SPRight) to create IdentityIQ objects, bypassing intended read-only restrictions. This enables privilege escalation to full system compromise through object creation. No active exploitation reported; a vendor patch is available.
XQUIC library through version 1.8.3 on Linux permits signature verification bypass and protocol manipulation via crafted QUIC STREAM frames, allowing network attackers to inject forged data into encrypted QUIC connections. Exploitation requires high complexity network interception but needs no authentication (CVSS:4.0 AV:N/AC:H/PR:N). No active exploitation confirmed (not in CISA KEV), but upstream fix available via GitHub commit 4764604a0e487eeb49338b4498aecda2194eae84. Affects applications usi
Authenticated remote code execution in Daylight Studio FuelCMS v1.5.2 allows low-privileged attackers to execute arbitrary operating system commands via the add_git_submodule method in the Installer controller. A publicly available proof-of-concept exploit exists, but no active exploitation has been reported and EPSS likelihood remains very low at 0.05%.
We need to produce a JSON object. Let's analyze the information: - CVE ID: CVE-2026-6311 - Product: Google Chrome on Windows (from description). Affected CPE: cpe:2.3:a:google:chrome:*:*:*:*:*:*:*:* with version prior to 147.0.7727.101. So product_name: "Google Chrome" (3 words, specific product). - Summary: Should be plain-language, original synthesis. Impact: Uninitialized use in Accessibility component allows attacker who compromised renderer to perform sandbox escape via crafted HTML page. Chromium security severity: High. EPSS: 0.02% low. No KEV. Patch available. Use data: remotely accessible, but attacker already needs renderer compromise. So the vulnerability exists within the browser, but exploit requires prior renderer compromise (maybe via another bug). So an attacker can escape the sandbox after compromising the renderer process. Mentions "remote attacker" but AV:N AC:H PR:N UI:R Scope Changed. But the description says "who had compromised the renderer process" i.e., that pre-condition of renderer compromise is needed, which is not reflected in CVSS vector? But the CVSS is from source. So we'll note this nuance. Not actively exploited, no POC mentioned. So summary: "Sandbox escape in Google Chrome on Windows prior to 147.0.7727.101 can be triggered by a remote attacker who has already compromised the renderer process, via a crafted HTML page, due to uninitialized memory use in the Accessibility component. This could allow escalation of privileges from the renderer sandbox to the broader system. No known active exploitation or public exploit code." - Technical context: CWE-457: Uninitialized Use. Accessibility component likely interfaces with Windows accessibility APIs (like IAccessible). Uninitialized memory can lead to arbitrary code execution. The renderer process is sandboxed, so escaping requires leveraging the bug to break out. Apple? CPE only Chrome. Use references to explain. Mention that vulnerability is due to using uninitialized variable in Ac
Sandbox escape in Google Chrome's GPU process allows an attacker who has already compromised the GPU process to break out of the sandbox via a crafted HTML page, potentially achieving full system compromise. The vulnerability is an out-of-bounds write patched in version 147.0.7727.101. No active
Sandbox escape vulnerability in Google Chrome's Dawn (WebGPU implementation) allows attackers who have already compromised the renderer process to escape the browser sandbox and execute arbitrary code on the host system via a malicious HTML page. The flaw, a use-after-free in Dawn, affects Chrome versions prior to 147.0.7727.101. No active exploitation or public proof-of-concept is reported at this time, and the EPSS score (0.02%) indicates low likelihood of widespread exploitation.
Sandbox escape via use after free in Google Chrome's Viz component prior to 147.0.7727.101. Exploitation requires a prior compromise of the renderer process and user interaction with a crafted HTML page. No active exploitation reported; EPSS indicates a very low probability of exploitation (0.02%).
Sandbox escape via a use-after-free in Google Chrome's Graphite component allows a remote attacker with an already compromised renderer process to potentially execute arbitrary code outside the sandbox. The vulnerability affects Chrome versions before 147.0.7727.101 and requires high attack complexity along with user interaction to trigger. No public exploit or active exploitation is known, and the EPSS score is very low (0.
We need to generate a comprehensive JSON analysis for CVE-2026-6361. Use all provided data: description, CVSS, CWE, EPSS, KEV status (not mentioned, so assume no KEV), patch availability, CPE, tags, SSVC, affected versions, references. The CVE is a heap buffer overflow in PDFium in Google Chrome on Windows. CVSS 8.3, vector AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H. EPSS 0.01% (low). SSVC: Exploitation none, Automatable yes, Technical Impact partial. Patch available from vendor. CPE: cpe:2.3:a:google:chrome:*:*:*:*:*:*:*:*. No KEV mention, so exploitation status: no public exploit identified, but there's a POC? Not mentioned, so none. In summary, actively exploited? No KEV, so "no public exploit identified at time of analysis". But tag says Microsoft, RCE, Heap Overflow, Buffer Overflow, Google. SSVC says automatable yes, but exploitation none. So POC not confirmed. Fields required: product_name (1-3 words): Google Chrome on Windows? The description says "PDFium in Google Chrome on Windows". So product_name: "Google Chrome on Windows" (3 words). Or "Google Chrome" (2 words). The CPE is just for chrome, so maybe "Google Chrome". I'll go with "Google Chrome" but note Windows platform in summary. product_name: "Google Chrome". That's the main product. Affected version <147.0.7727.101. So Chrome. Good. summary: Not copy description, original synthesis. Must start with impact verb and product. "Remote code execution in Google Chrome on Windows version prior to 147.0.7727.101 allows a remote attacker to execute arbitrary code inside the sandbox via a crafted PDF file." Add EPSS, KEV. EPSS low, no active exploitation. Mention High severity from Chromium. Be concise, 2-3 sentences. technical_context: Underlying technology: PDFium is the PDF rendering library in Chromium, used for PDF display. Heap buffer overflow, CWE-122. Affected products from CPE: Google Chrome on Windows (because description says Windows, but CPE doesn't specify OS; possibly Chrome on any platform? Actuall
Sandbox escape via use-after-free in Google Chrome's Proxy component allows network‑positioned attackers to execute arbitrary code outside the browser sandbox. Affected are Chrome versions prior to 147.0.7727.101. No active exploitation or public exploit code has been identified at time of analysis.
We need to produce a JSON object per the instructions. Let's analyze each field. First, product_name: "1-3 words ONLY. The specific product or service name affected." CVE affects Apache Airflow example documentation. However, the vulnerability is in the documentation example that users might have copied. The product is Apache Airflow, specific component: documentation/examples. But the description says "It does not affect Airflow release". The vulnerable pattern is in the documentation, and users who followed it may have vulnerable code. So the primary product is Apache Airflow? The CPE: apache:airflow.* So product_name: "Apache Airflow" fits. Possibly "Apache Airflow documentation" but not typical. Product name should be the software. It says "1-3 words ONLY", so "Apache Airflow" is two words. That is good. summary: "2-3 sentence plain-language summary for security professionals. CRITICAL: Do NOT copy or paraphrase Description — write an original synthesis... Start with the specific impact verb and product, e.g. 'Remote code execution in Apache Tomcat 9.x allows...'. Explain WHAT the vulnerability is, WHO is affected (specific product/version), and WHAT an attacker can do. Mention if actively exploited (KEV), if POC exists, and EPSS risk if notable." From the description: The example_xcom example in Airflow documentation implemented an unsafe pattern of reading XCom values, which could allow a UI user who can modify XComs to execute arbitrary code on the worker. It's a code injection via unsafe pattern, but only if the user replicated the pattern. The vulnerability is not in the product itself but in the example. The CVSS is 8.1, which seems high for something that requires the user to copy a bad pattern. But it's rated Low severity. EPSS is 0.03%, very low. No KEV mentioned. Patch: documentation updated in Airflow 3.2.0. So we need to synthesize: "Code injection in Apache Airflow's example_xcom documentation that, if followed by users, allows UI users with XCom modification privileges to execute arbitrary code on the worker. Affects users who implemented the documented unsafe pattern; Airflow 3.2.0 documentation provides a safer alternative." Mention EPSS 0.03%, no known active exploitation, no public POC? Actually, there is no mention of POC apart from the CVE itself being published, but the description suggests it's just a pattern. Not a POC exploit. So "no public exploit identified". We'll say "not actively exploited" and "EPSS score 0.03% suggesting minimal exploitation likelihood". So summary: "Code injection in Apache Airflow's example_xcom documentation allows UI users who can modify XComs to execute arbitrary code on the worker. This risk exists only for deployments that replicated the unsafe pattern from the documentation. Airflow 3.2.0 updated documentation to recommend a safe pattern, and EPSS data indicates a very low exploitation probability (0.03%)." That's 2-3 sentences. No copy. technical_context: Explain underlying technology/library/protocol. CWE-94: Code Injection. XCom (cross-communication) in Apache Airflow is a mechanism for tasks to exchange data. The example showed directly templating XCom values into a bash command string without proper escaping or validation, enabling command injection. The CPE confirms affected product Apache Airflow all versions before 3.2.0 (since the documentation existed before that version). The root cause: improper neutralization of special elements in a command (CWE-94). So we can explain that. risk_assessment: "Assess real-world risk using ALL available signals: CVSS vector (attack vector, complexity, privileges), EPSS exploitation probability, KEV status, POC availability, SSVC decision framework (exploitation status, automatable, technical impact). Compare and contrast these signals. Is this a real priority or just a high-CVSS-but-low-real-risk issue? If any key data is missing or conflicting, STATE IT EXPLICITLY." CVSS 8.1: AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N. That's high, but EPSS 0.03% is very low. SSVC: Exploitation: none, Automatable: no, Technical Impact: total. So exploitation is not active, not automatable, but total impact if exploited. That suggests high impact but low likelihood because it requires a user to have copied a specific pattern from documentation. The vulnerability is not in the core product but in user implementations. So it's a documentation issue, not a product vulnerability. Many users might not have enabled example dags or copied that pattern. So high CVSS but low real risk. Conflicting: CVSS indicates network attack vector, low privileges, no user interaction, but in practice, the attacker must be an UI user with XCom modification rights, which is authenticated. That matches PR:L. AV:N is plausible if the Airflow UI is network accessible. AC:L because the pattern is easy to exploit if the vulnerable code exists. So it's a high-severity issue if the user has the vulnerable code, but the footprint is likely tiny. So prioritize low. We'll state that. affected_products: Write a concise paragraph listing affected products with versions. "Apache Airflow documentation versions prior to 3.2.0 contain the unsafe pattern in example_xcom.py. Users who implemented the example pattern in their DAG code are affected regardless of Airflow version. Airflow 3.2.0 documentation includes the corrected safe pattern. CPE: cpe:2.3:a:apache_software_foundation:apache_airflow:*:*:*:*:*:*:*:*. EUVD lists affected versions: Apache Airflow 0 <3.2.0." Note: the patch is a documentation update, not a code fix. So affected products are Airflow documentation versions before 3.2.0, and downstream users' custom code. So we can state that. remediation: "Write a concise paragraph with actionable remediation steps. Start with the primary fix (patch/upgrade with exact version), then mention workarounds if relevant. Include advisory URLs... If no patch is available, suggest SPECIFIC compensating controls." The advisory says: Documentation of Airflow 3.2.0 contains improved version. So users should review their code and adopt the safe pattern shown in the updated example (using environment variables instead of direct templating). No code patch needed because the vulnerability is in user code. So remediation: "Review any custom DAG code that uses XCom value to construct bash commands, and refactor to use the safe pattern from Airflow 3.2.0 documentation: pass XCom values as environment variables and reference them via $VAR in the command." We can refer to the PR and advisory. Also, as a general measure, restrict XCom modification permissions to trusted UI users. But that's already indicated: UI users already highly trusted. So no need. So the primary remediation is to change user code. The advisory URL: https://lists.apache.org/thread/3mf4cfx070ofsnf9qy0s2v5gqb5sc2g1 exploit_scenario: "Brief realistic attack scenario in 2-3 sentences. If POC exists, note that. Factor in attack vector and complexity from CVSS." An attacker with Airflow UI access (low privilege, XCom modification rights) could replace an XCom value with a malicious command payload. When a DAG task uses the unsafe pattern to read that XCom and execute it in bash, the malicious command runs on the worker node. This could lead to data exfiltration or further compromise. No public POC, but the pattern is straightforward. exploitation_conditions: CRITICAL FIELD. Need specific, concrete prerequisites. From description: "UI user who had access to modify XComs" and "users following the example could replicate the bad pattern". So conditions: 1) The Airflow deployment must contain a DAG that directly templates XCom values into a bash command (the unsafe pattern). 2) The attacker must have UI access with permission to modify XCom values (i.e., at least read/write on the target XCom). 3) The DAG must be triggered, and the task that reads the XCom and executes the command must run after the XCom value is poisoned. So the exploitation conditions: "The target environment must contain a DAG task that unsafely constructs a bash command using XCom values (as shown in the affected example). An attacker must be an authenticated Airflow UI user with privileges to modify the XComs used by that DAG. The attacker then triggers the DAG, causing the injected command to execute on the worker." Also note: No special configuration per se, but the presence of the vulnerable pattern is required. I'll phrase it carefully. attack_chain: "3-7 short steps separated by ' → ' (arrow). Must be grounded in actual CVE data." Kill chain phases. Potential steps: Authenticate as UI user with XCom write permissions → Poison target XCom with malicious shell command → Trigger DAG run that reads the poisoned XCom → DAG task templates XCom into bash command without sanitization → Bash executes the payload → Achieve code execution on worker node. So chain: "Authenticate to Airflow UI as user with XCom write access → Locate target DAG that uses unsafe XCom pattern → Inject malicious command into XCom variable → Trigger DAG run that reads the XCom → BashOperator executes crafted command → Gain arbitrary code execution on worker". That's 6 steps. Use arrow. confidence_notes: "1-3 sentences about data completeness and confidence. State what is CONFIRMED, what is INFERRED, what is UNKNOWN." Confirmed: The unsafe pattern existed in example documentation before 3.2.0 (confirmed by GitHub diff). The vulnerability description confirmed by Apache advisory. The patch is documentation update, not code change. CVSS vector provided by NVD. EPSS low. No active exploitation. Unknown: exact number of users who copied the pattern, but likely low. So confidence: "Vulnerability confirmed by Apache advisory and GitHub PR. The CVSS vector is from NVD. No active exploitation detected, EPSS extremely low. The number of affected deployments replicating the example is unknown but likely minimal." prevalence: ONE word only: low? Airflow is widely used enterprise scheduler, but the vulnerability is not in the default installation; it's only if someone copied that specific pattern. So the product itself (Apache Airflow) is high prevalence, but the vulnerable code pattern is not ubiquitous. The prevalence field is about "REAL-WORLD deployment footprint of the affected product". The affected product as defined in product_name is Apache Airflow. But the vulnerability is in the documentation example, not the product itself. However, the question asks: "Estimate the REAL-WORLD deployment footprint of the affected product — how widely it is actually deployed in production." So Airflow is widely deployed. But the CVE description says "It does not affect Airflow release - example_dags are not supposed to be enabled in production environment, however users following the example could replicate the bad pattern." So the affected product is actually the documentation and the users' custom code. The product is Apache Airflow, but the vulnerability is not in the released software. So the deployment footprint of Apache Airflow is high, but the vulnerable scenario is rare because it requires manual copying of an example. So the prevalence of the actual vulnerable condition is low. But the field asks for "prevalence" of the affected product. It says "ubiquitous | high | medium | low | rare | unknown". The product is Apache Airflow. That could be "high" because Airflow is widely used in data engineering. But then the vulnerability itself is low prevalence. However, I think it's meant to be the product, not the vulnerability. The guidelines: "Estimate the REAL-WORLD deployment footprint of the affected product — how widely it is actually deployed in production. This is INDEPENDENT of severity (a CRITICAL flaw in a rare product is still rare)." So if the product is Apache Airflow, it's high. But then the vulnerability is just a documentation issue, and it's not in the product itself, but the CVE is tied to the product. I'll decide: product is Apache Airflow, so prevalence should be high because many enterprises use it. But the description says "It does not affect Airflow release", so maybe they don't consider the product as vulnerable. Yet the CPE lists Apache Airflow as affected. The affected product string often includes the software that has the flaw, even if it's just documentation. So I'll set prevalence to high, because Apache Airflow is a widely-deployed enterprise scheduler. Prevalence basis: "widely-deployed enterprise workflow scheduler". However, given that the actual flaw is in user code and not default, maybe the prevalence of the vulnerable code pattern is low, but the product prevalence is high. The instruction says: "the affected product — how widely it is actually deployed in production." The affected product is Apache Airflow, so high. I'll go with high. prevalence_basis: "core data pipeline tool,
Authorization bypass in FluentBoards up to 1.91.2 allows authenticated users to access and modify board data belonging to other users. The vulnerability, categorized as CWE-639, stems from improper access controls on user-controlled keys. At the time of analysis, no active exploitation has been reported, and EPSS indicates a very low exploitation probability (0.02%).
Cross-site request forgery in WPForms Lite up to version 1.10.0.2 allows unauthenticated attackers to perform unauthorized actions by tricking an authenticated administrator into clicking a malicious link, resulting in high confidentiality and integrity impact. No active exploitation or public proof-of-concept is currently known, and EPSS indicates very low exploitation probability (0.01%).
We need to produce a JSON object for CVE-2026-33435 based on all provided intelligence. The user gave description, CVSS, CWE, EPSS, patch status, tags, CPE, SSVC, references, etc. We must synthesize all into the specified fields. Let's extract key information: - Product: Weblate (web based localization tool) - Vulnerability: In versions prior to 5.17, project backup didn't filter Git and Mercurial configuration files, leading to remote code execution under certain circumstances. Fixed in 5.17. - CVSS 3.1: AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H (8.0) - CWE: CWE-23 (Relative Path Traversal) – but actually from description it's about unsafe inclusion of VCS config files (lack of sanitization of uploaded backup containing .git/config, hooks, etc.). The fix adds filtering of those paths. So it's more an issue of untrusted data used in backup restoration leading to RCE. CWE-23 might be a misclassification; but we'll incorporate the CWE provided. - EPSS: 0.33% (56th percentile) – relatively low exploitation probability. - SSVC: Exploitation: none, Automatable: no, Technical Impact: total. So no active exploitation, not automatable, total impact. This would prioritize moderately (in SSVC, if exploitation is none, but tech impact total, may still be "attend" but more a "scheduled"). - Tags: RCE, Weblate - CPE: cpe:2.3:a:weblateorg:weblate:*:*:*:*:*:*:*:* (all versions) - Affected versions: weblate < 5.17 - Patch: Available from vendor, fixed in version 5.17. PR #18549 available. - References: GitHub advisory, PR diff. - Exploit status: No mention of KEV, so not KEV. No public exploit identified. From advisory: reported via HackerOne, but no indication of public exploit or active exploitation. So "no public exploit identified at time of analysis". - EPSS low, so unlikely widespread exploitation. - CVSS vector indicates AV:N (network), AC:H (high complexity), PR:H (privileges required high), UI:N (no user interaction), S:C (scope changed), C/H, I/H, A/H. This means a high-privi
Remote command execution via prompt injection in Windsurf 1.9544.26 allows attackers to register malicious MCP STDIO servers through crafted HTML content, leading to arbitrary command execution without further user interaction after initial payload delivery. No active exploitation or public exploit code has been reported, and EPSS suggests very low exploitation probability (0.04%). The vulnerability has a CVSS base score of 8.0, but the local attack vector and required user interaction significantly limit real-world risk.
We need to produce a JSON object with all specified fields, based on provided data. The CVE is CVE-2026-6290, about Velociraptor query() plugin allowing cross-org access in the GUI. Let's synthesize. Inputs: - Description: Velociraptor versions prior to 0.76.3 contain a vulnerability in the query() plugin which allows access to all orgs with the user's current ACL token. Authenticated GUI user with access in one org can use the query() plugin in a notebook cell to run VQL queries on other orgs they may not have access to. User's permissions in the other org are same as they have in the org containing the notebook. - CVSS Score: 8.0, Vector: AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H - CWE-863: Incorrect Authorization. - EPSS: 0.03% (percentile 8%) - very low exploitation probability. - Patch: Available (from vendor). References include advisory URL: https://docs.velociraptor.app/announcements/advisories/cve-2026-6290/ which presumably mentions fix version 0.76.3. - KEV: not mentioned, so not in CISA KEV. No exploitation evidence. - POC: not mentioned, probably none. - Tags: Authentication Bypass, Velociraptor (maybe they consider the cross-org access as bypassing auth? It says "Authentication Bypass" tag, but it's actually an incorrect authorization after authentication. CWE-863 is Incorrect Authorization, not bypass. We'll stick to description). - SSVC: Exploitation: none, Automatable: no, Technical Impact: total. That means not exploited, not automatable, but total impact if exploited. - ENISA EUVD: lists affected versions: Velociraptor 0 <0.76.3, 0.75.8 (maybe separate branch?). - CPE: cpe:2.3:a:rapid7:velociraptor:*:*:*:*:*:*:*:* (prior to 0.76.3). - References: advisory from docs.velociraptor.app, NVD page, vuldb. Now, build JSON fields: product_name: "Velociraptor" - simple. summary: Need original synthesis, not copy description. Start with impact verb and product. So: "Incorrect authorization in Velociraptor versions prior to 0.76.3 allows an authenticated GUI user to execute VQL queries on organizations other than their own via the query() plugin in notebooks. The user's permissions in the target org mirror those in the source org. No active exploitation or public exploit code has been reported; EPSS score is low (0.03%)." That covers what, who, impact, exploitation status, EPSS. Use KEV: not present. Mention authenticated, high privileges (PR:H), UI:N, AC:H (complex? High complexity). But we don't need full CVSS in summary. Good. technical_context: Explain underlying technology. Velociraptor is an open-source endpoint visibility, digital forensics, and incident response tool. The query() plugin is a VQL (Velociraptor Query Language) function that allows running queries. The vulnerability relates to authorization checks in multi-org deployments: the plugin fails to properly scope the user's access to only the current organization, allowing cross-org querying. CWE-863 Incorrect Authorization. CPE shows product: rapid7:velociraptor. The affected versions are prior to 0.76.3. So we can mention that. risk_assessment: Use CVSS, EPSS, KEV, SSVC. CVSS: 8.0 high, network vector, high complexity, high privileges, no user interaction, scope changed, high impact all. EPSS 0.03%, very low likelihood of exploitation. KEV not listed. SSVC: Exploitation none, not automatable, but total impact. So real-world risk is low for widespread exploitation due to high privileges required and lack of automation; but if exploited by a malicious insider with high-privileged access in one org, they could compromise other orgs. The high CVSS score reflects the potential damage from an authenticated user, but the EPSS score suggests minimal real-world exploitation. So it's a priority for organizations using multi-org Velociraptor deployments, but not an immediate patch-everything emergency unless you have malicious insiders. No evidence of active exploitation. State clearly: "CVSS score 8.0 indicates high severity, but exploitation requires an authenticated GUI user with high privileges in at least one organization. EPSS probability is 0.03%, suggesting very low likelihood of widespread exploitation. No active exploitation reported (SSVC: exploitation none, not automatable). This vulnerability is primarily a concern for organizations running multi-org Velociraptor with high-privileged users who should not have cross-org access." affected_products: "Velociraptor versions prior to 0.76.3 are affected, as confirmed in vendor advisory (https://docs.velociraptor.app/announcements/advisories/cve-2026-6290/). The CPE identifier is cpe:2.3:a:rapid7:velociraptor:*:*:*:*:*:*:*:*. A specific affected version is 0.75.8, but all versions before 0.76.3 are vulnerable." That covers. No need to list all. remediation: "Upgrade to Velociraptor version 0.76.3 or later, which contains the fix. The vendor advisory at https://docs.velociraptor.app/announcements/advisories/cve-2026-6290/ provides details. As a workaround, restrict the use of the query() plugin in notebooks to only trusted users, or disable multi-org deployments if not needed." Patch available, so primary is upgrade. exploit_scenario: "An attacker who already has authenticated GUI access with high privileges (e.g., administrator) in one organization crafts a malicious VQL query within a notebook cell using the query() plugin. By specifying a target organization other than the current one, the query executes with the attacker's permissions in that target org, potentially accessing artifacts, collected data, or executing further VQL commands. This can lead to cross-org data exfiltration or lateral movement within the Velociraptor server." Note: requires authentication and high privileges, so it's an insider threat or compromised account. exploitation_conditions: Need specific prerequisites. From description: "authenticated GUI user with access in one org" and "using the query() plugin in a notebook cell". So the conditions: user must have an account with high privileges (PR:H from CVSS) and access to at least one organization; multi-org deployment; the query() plugin must be available in notebooks (default). The attack requires the user to intentionally craft queries targeting other orgs. There's no user interaction from the target. So state: "Exploitation requires an authenticated GUI user with high privileges in at least one organization in a multi-org Velociraptor deployment. The user must have access to notebooks and the query() plugin (enabled by default). The attack can be performed without any user interaction or special privileges beyond the initial authentication to the source org." That's precise. attack_chain: Need kill chain steps. Likely: Access (authenticate to GUI) -> Delivery (open notebook cell) -> Exploit (craft VQL query with query() plugin targeting different org) -> Execution (query runs in target org with user's permissions) -> Impact (access/modify data in other org). So: "Authenticate to Velociraptor GUI → Open a notebook cell → Craft VQL query using query() plugin targeting another organization → Query executes in target org with same permissions → Access or modify data across organizations". Can make it concise: "Authenticate to GUI → Create notebook cell → Issue cross-org VQL query via query() plugin → Execute query in target org → Read/write cross-org data". That's 5 steps. Good. confidence_notes: What is confirmed? Vendor advisory confirms the vulnerability and fix version 0.76.3. NVD confirms CVE and scoring. EUVD confirms affected versions. No evidence of exploitation, no POC mentioned. Patch is available. CVSS vector is provided. So confidence high. "Vendor advisory confirms affected versions (<0.76.3) and patch version (0.76.3). NVD assigns CVSS 8.0 with high complexity and privileges. No public exploit or active exploitation reported; EPSS score is low. All critical details appear confirmed." Good. prevalence: How widely deployed is Velociraptor? It's an open-source DFIR tool by Rapid7, not as widespread as enterprise tools like Splunk or Sentinel, but used in security operations. Prevalence likely "medium" - not ubiquitous, but not rare. So "medium". prevalence_basis: "Popular open-source DFIR tool used in enterprise SOCs" - max 12 words. "widely-used digital forensics tool in security operations" but within limit. assessed_cvss_vector: We need our own independent vector. Description: network vector, but requires authenticated GUI access. Attack complexity high? Probably yes, because it requires crafting VQL queries and knowing the org structure. Privileges high (user must have high privileges in at least one org). No user interaction. Scope changed (accessing other org). Impact high for confidentiality, integrity, availability because they can run queries that read, modify artifacts or even execute commands? The description says run VQL queries on other orgs with same permissions; if permissions include high, they could do anything. So C/I/A all high. So same as provided: AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H. But we must output our own, but it matches. So I'll output that exact vector. But the instructions say "Your OWN independent CVSS 3.1 base-metric vector ... grounded in the description and exploitation conditions — NOT a copy of any score in the input." But the input vector seems reasonable, so we can still use that. We'll output: "CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:C/C:H/I:H/A:H". That's consistent. rationale: "Requires authenticated high-privileged GUI user, high attack complexity due to crafting cross-org queries, and scope change to other organizations." assessed_cvss40_vector: Map to CVSS 4.0 base vector: AV:N, AC:H (attack complexity high), AT:N (no attack requirements just conditions). PR:H (high privileges), UI:N. VC:C, VI:C, VA:C (vulnerable system? In 4.0, vulnerable system is the component being exploited, probably the Velociraptor server API or plugin, so all high impact on vulnerable system, and subsequent system impact? Scope changed: the query() plugin allows accessing other orgs, so there is a subsequent system (the other org's data environment). In CVSS 4.0, if there is a scope change, you set SC/SI/SA accordingly. But the vulnerable component is the plugin that fails to restrict access, allowing impact on a different security scope (other orgs). So VC/VI/VA are the impact on the vulnerable component itself? Actually, the vulnerable component is the query() plugin, and exploiting it allows impact on the target org's data, which is a secondary scope. So SC,SI,SA would reflect the impact on the other org (confidentiality, integrity, availability high). In CVSS 4.0, base metrics: AV:N/AC:H/AT:N/PR:H/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H. But careful: VC/VI/VA refer to impact on the vulnerable system, i.e., the system that contains the vulnerability (the plugin or server). Does exploiting the vulnerability directly affect the vulnerable system's own confidentiality, integrity, availability? The query runs on the target org, which might be separate virtual scope, but the vulnerable system (the server that processes the query) might still be unaffected except that it now returns data. So maybe the vulnerable system (the plugin) does not suffer a confidentiality/integrity/availability loss itself; the impact is entirely on the subsequent system. Then VC/VI/VA would be N/N/N. However, I think the standard interpretation is that if the vulnerable component's functions allow access to other resources, you set VC/VI/VA to reflect the impact to the vulnerable component itself, but if the scope changes (i.e., you can affect a different component), you set SC/SI/SA to the impact on that other component, and VC/VI/VA to the impact on the vulnerable component if any. Here, the plugin itself isn't harmed, but the attacker can read/write data in another org which is a separate security scope, so VC/VI/VA could be N. But
Buffer overflow in GIMP's GIF image loading component allows arbitrary code execution when a victim opens a specially crafted GIF file. This local‑attack vulnerability (CVSS 3.1: AV:L/PR:N/UI:R) can lead to full compromise of the user's session. No public exploit has been identified, and EPSS exploitation probability is very low (0.01 %).
DLL hijacking in OMRON PowerAttendant Standard Edition UPS management software allows local attackers with low privileges to escalate to SYSTEM by planting malicious libraries in the installation directory, which are loaded during service startup. The attack requires high complexity (vulnerable directory permissions must exist) but achieves scope change with full system compromise. No public exploit identified at time of analysis, though the DLL hijacking technique (CWE-427) is well-documented a
Arbitrary file read vulnerability in Weblate versions prior to 5.17 allows authenticated attackers to read sensitive files from the server via symlink traversal in the ZIP download feature. No active exploitation or public exploit code has been identified, and the EPSS score (0.01%) indicates very low likelihood of exploitation. A vendor-released patch is available in Weblate 5.17.
Limited file disclosure and server-side request forgery in OpenRemote Manager through 1.21.0 allow authenticated low-privileged users to read local files under 1023 characters from the Manager host and initiate outbound connections. A publicly available proof-of-concept exists, but no active exploitation has been reported. The EPSS probability is very low at 0.06%.
SQL injection in the WCFM Marketplace plugin for WordPress allows authenticated high-privilege users (e.g., administrators or shop managers) to extract sensitive information from the site's database. Versions up to and including 3.7.1 are affected. No active exploitation or public exploit code has been identified, and EPSS indicates a very low probability of exploitation.
Blind SQL injection in Element Pack Elementor Addons for WordPress versions through
Directory traversal in SAC-NFe v2.0.02 allows unauthenticated attackers to read arbitrary files from the server via crafted GET requests to download.php. The flaw exposes sensitive files, potentially including credentials or configuration data, and a proof-of-concept exploit is publicly available, though active exploitation has not been confirmed.
Remote code execution in Google Chrome on Android versions prior to 147.0.7727.101 is possible through a use-after-free vulnerability in the Payments feature. Attackers who successfully convince users to perform specific UI interactions on a malicious webpage can achieve arbitrary code execution with high impact to confidentiality, integrity, and availability. The vulnerability requires high attack complexity and user interaction (CVSS:3.1/AV:N/AC:H/PR:N/UI:R), indicating social engineering is necessary. Google has released Chrome 147.0.7727.101 to address this issue. No evidence of active exploitation (not in CISA KEV) or public proof-of-concept code has been identified at time of analysis.
Out-of-bounds read in Google Chrome's media component (versions prior to 147.0.7727.101) enables remote code execution when attackers convince users to perform specific UI interactions on a malicious HTML page. Google rated this high severity and released Chrome 147.0.7727.101 as a fix. No active exploitation confirmed via CISA KEV at time of analysis, though CVSS 7.5 reflects significant impact if user interaction prerequisite is met. The UI gesture requirement and high attack complexity (AC:H) reduce automated exploitation risk compared to interaction-free vulnerabilities.
Sensitive information disclosure in Slah v1.5.0 and below allows unauthenticated remote attackers to read the contents of config.php and extract active session credentials. The vulnerability permits high-confidentiality impact with no user interaction required, enabling session hijacking and unauthorized access. A proof-of-concept exploit is publicly available,
Remote validation bypass in Fastify 5.3.2+ allows unauthenticated attackers to bypass per-content-type body schema validation by prepending a single space character to the Content-Type HTTP header. Applications using schema.body.content for request validation accept malformed or malicious payloads that should be rejected, enabling data integrity violations. This regression was introduced by the fix for CVE-2025-32442. EPSS data not available; no confirmed active exploitation (CISA KEV) or public exploit code identified at time of analysis. Affects Fastify web framework version 5.3.2 through 5.8.4.
Uncontrolled Resource Consumption in Bosch VMS Central Server in Bosch VMS 12.0.1 allows attackers to consume excessive amounts of disk space via network interface. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.
Connection slot exhaustion in Deadwood (MaraDNS 3.5.0036) allows remote unauthenticated attackers to cause denial of service by triggering lookups for zones with unresolvable authoritative nameserver addresses. This resource exhaustion vulnerability (CWE-670) has CVSS 7.5 severity and EPSS data indicates low exploitation probability. No public exploit identified at time of analysis, though the attack mechanism appears straightforward given the network-accessible attack vector with low complexity.
CentSDR's Thread1 function suffers a remote stack overflow, leading to denial of service without authentication. A public proof-of-concept is available, but no active exploitation has been observed. The low EPSS score and niche user base suggest limited real-world risk despite the high CVSS score.
Payment bypass in the Accept Cryptocurrencies with Plisio WordPress plugin through version 2.0.5 allows unauthenticated attackers to manipulate order payment statuses due to missing authorization checks. This high‑integrity vulnerability can be exploited to mark orders as paid without a legitimate transaction, enabling financial fraud. No active exploitation or public proofs of concept have been observed, and EPSS indicates a very low likelihood of in‑the‑wild attacks.
We need to produce a comprehensive JSON object. All fields must be plain text strings. We synthesize from the provided data. Given data: - CVE-2026-5088 - Description: Apache::API::Password versions through v0.5.2 for Perl can generate insecure random values for salts. The _make_salt and _make_salt_bcrypt methods will attempt to load Crypt::URandom and then Bytes::Random::Secure to generate random bytes for the salt. If those modules are unavailable, it will simply return 16 bytes generated with Perl's built-in rand function. The rand function is unsuitable for cryptographic use. These salts are used for password hashing. - CVSS Score: 7.5 - CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N - CWE: CWE-338 (Use of Cryptographically Weak Pseudo-Random Number Generator (PRNG)) - EPSS: 0.02% (percentile 4%) - Reported by: CPANSec - CPE: cpe:2.3:a:jdeguest:apache::api::password:*:*:*:*:*:*:*:* (probably means Apache::API::Password all versions up to v0.5.2) - Tags: Apache, Information Disclosure - SSVC: Exploitation: none, Automatable: yes, Technical Impact: partial - ENISA EUVD ID: EUVD-2026-22840 - Affected versions (EUVD): ["Apache::API::Password 0 ≤ v0.5.2"] - References: [cveorg] changes file for v0.5.3: https://metacpan.org/release/JDEGUEST/Apache2-API-v0.5.3/changes [cveorg] v0.5.2 view of Password.pod: https://metacpan.org/release/JDEGUEST/Apache2-API-v0.5.2/view/lib/Apache2/API/Password.pod [cveorg] security guide: https://security.metacpan.org/docs/guides/random-data-for-security.html [cveorg] Crypt::URandom pod: https://metacpan.org/pod/Crypt::URandom [vuldb] advisory: https://vuldb.com/vuln/357672 [nvd] oss-security list post 1: http://www.openwall.com/lists/oss-security/2026/04/15/4 [nvd] oss-security list post 2: http://www.openwall.com/lists/oss-security/2026/04/15/5 [euvd] advisory: https://nvd.nist.gov/vuln/detail/CVE-2026-5088 We need to extract the fix: According to the changes reference, it points to Apache2-API-v0.5.3 chan
Denial of service in Nordic Semiconductor IronSide SE for n
Unauthenticated access to Apache SkyWalking 9.7.0 to 10.3.0 allows remote attackers to retrieve sensitive MySQL/PostgreSQL configuration details through the /debugging/config/dump endpoint. No active exploitation or public exploit code is known, though the attack is trivial and automatable. The low EPSS score (0.02%) indicates minimal real-world exploitation likelihood.
Credential hash disclosure in Git for Windows versions prior to 2.53.0.windows.3 allows unauthenticated remote attackers to obtain a user's NTLM hash by tricking them into cloning a malicious repository or checking out a malicious branch that contacts an attacker-controlled server. The extracted hash can be brute-forced offline to recover plaintext credentials, though no active exploitation or public exploit has been identified at time of analysis and EPSS likelihood is very low (0.06%).
Two-factor authentication bypass in OpenProject before 17.3.0 allows attackers with a known password to brute-force the TOTP code, gaining full account access. No rate limiting or lockout mechanism exists for the 2FA verification endpoint, making it possible to cycle through the 6‑digit code in roughly 11 hours under default settings. The flaw also affects backup code verification, completely negating 2FA protection; publicly available exploit code exists based on SSVC intelligence, though EPSS indicates a low exploitation probability.
Remote command injection in Jaaz 1.0.30 allows unauthenticated attackers to execute arbitrary commands on the underlying server via crafted MCP STDIO requests. The vulnerability resides in the application's handling of the Model Context Protocol (MCP) over standard input/output, and despite a CVSS score of 7.3 with low impact metrics, the description indicates full compromise is possible. No active exploitation or public exploit code has been identified, but the flaw is automatable and remotely exploitable without privileges.
Local privilege escalation in HP Omen Gaming Hub versions prior to 1101.2603 allows a low-privileged local attacker to execute arbitrary code with SYSTEM privileges. A public proof-of-concept detection template exists, but no active exploitation has been reported. The vulnerability is rated High severity with an EPSS of 0.01%, indicating low near-term exploitation probability.
Stored XSS in Accessibly WordPress plugin (≤3.0.3) allows unauthenticated attackers to inject malicious JavaScript executed by all site visitors via unprotected REST API endpoints. Two endpoints (/otm-ac/v1/update-widget-options and /otm-ac/v1/update-app-config) lack authentication checks (permission_callback set to __return_true), enabling attackers to modify the widgetSrc option with a URL pointing to attacker-controlled scripts. The malicious URL is stored unsanitized in WordPress options and
Stored Cross-Site Scripting in Quick Interest Slider plugin for WordPress (versions ≤3.1.5) allows unauthenticated remote attackers to inject malicious scripts via unsanitized 'loan-amount' and 'loan-period' parameters. Injected scripts execute in victim browsers when accessing compromised pages, enabling session hijacking, credential theft, or malicious redirects. CVSS 7.2 with network-accessible, low-complexity attack vector (AV:N/AC:L/PR:N) and scope change (S:C) indicates significant cross-tenant impact. No public exploit identified at time of analysis, though exploitation requires minimal technical sophistication due to unauthenticated attack surface.
Stored Cross-Site Scripting in Token of Trust WordPress plugin versions ≤3.32.3 allows unauthenticated remote attackers to inject malicious scripts via the unsanitized 'description' parameter, achieving persistent code execution in victim browsers with changed security context (CVSS scope changed). CVSS 7.2 with network attack vector and no authentication required. No public exploit identified at time of analysis, but EPSS data not provided to assess exploitation probability.
Splunk MCP Server below version 1.0.3 logs session and authorization tokens in clear text within the `_internal` index, exposing them to any user with access to that index or the high-privilege `mcp_tool_admin` capability. A remote attacker with high privileges can view these tokens via the Splunk search interface, enabling session hijacking and impersonation of other users. No public exploit is identified at time of analysis, and the EPSS score of 0.04% indicates very low near-term exploitation probability.
Privilege escalation in Nozomi Networks Guardian and CMC Threat Intelligence module allows authenticated view-only users to perform administrative actions, including modifying or deleting threat intelligence rules. With CVSS 8.1 (High) driven by high integrity and availability impact, this access control bypass (CWE-863) enables low-privileged users to alter critical security configurations remotely. No public exploit identified at time of analysis, though EPSS data unavailable. Authentication requirements lower the barrier only slightly, as compromised low-privilege accounts are common in enterprise environments.