Cross-site scripting in IBM Financial Transaction Manager (FTM) for Red Hat OpenShift allows a remote, unauthenticated attacker to inject HTML/JavaScript that executes in the browser of a logged-in FTM operator, because HTML input is not properly neutralized (CWE-79). Exploitation requires the victim to load attacker-controlled content while holding an authenticated FTM session, so a successful attack is gated on user interaction and is confined to the victim's browser context rather than the FTM host itself. IBM has published a vendor advisory with fix guidance, no public exploit code and no confirmed active exploitation were identified at time of analysis, and EPSS data was not provided; the independent assessment rates this as CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, a lower integrity impact than the 8.2 base score supplied with the CVE, and the deployment is narrowed by FTM's specialized financial-transaction-processing footprint on OpenShift.
Arbitrary file upload in College-Notes-Gallery (rolling release up to commit 8c1cf3d98f30982d069c88ca172612c001eb39f6) lets authenticated remote attackers manipulate the 'image' parameter at /dashboard/userprofile.php?section=admin1 to bypass intended file-type restrictions and store arbitrary files on the server. Publicly available exploit code exists, but there is no KEV confirmation in the provided data, and the vendor did not issue a patch. The independent assessment rates this as a low real-world priority because valid credentials are required, the project is obscure with a tiny install base, and no official fix exists; the resulting impact can nevertheless be high if uploaded files are web-accessible and executable.
Reflected cross-site scripting in the WordPress Booking Calendar plugin (wpdevelop) affects every release up to and including 11.8.3, letting unauthenticated attackers craft a link that injects arbitrary JavaScript into a victim's browser within the target site's origin. Because the CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N (score 6.1, Medium), exploitation needs no credentials but does require a victim to click a malicious link, and the scope-change flag reflects that the injected script runs against the surrounding WordPress site rather than the plugin alone. No public exploit identified at time of analysis, and no CISA KEV listing or exploit code has been associated with this issue.
Reflected cross-site scripting in web.py 0.76 allows remote, unauthenticated attackers to inject and execute arbitrary JavaScript in a victim's browser session, because the framework's render_jinja.__init__() code path does not adequately constrain output escaping for user-controlled input that reaches Jinja-rendered templates. Exploitation requires the target application to actually route untrusted input into a render_jinja-generated response and requires victim interaction (UI:R) - the user must open an attacker-crafted link or supply attacker-influenced data - and the resulting impact is confined to the victim's browser within the site's origin (scope-changed, low confidentiality and integrity impact, no availability loss). No confirmed active exploitation (not in CISA KEV), no public exploit code identified at time of analysis, and EPSS is low at 0.19% (9th percentile), so real-world risk is governed primarily by whether a deployment passes untrusted data into Jinja-rendered output.
Authenticated SQL injection in Yonyou U8cloud 5.x lets a low-privilege OpenAPI user inject arbitrary SQL through the 'operator' argument of the /u8cloud/openapi/so.saleorder.sendaudit endpoint, potentially exposing or altering data held in the application's backend database. Exploitation is remote and requires no user interaction, but does require a valid low-privilege OpenAPI account and network reachability to the OpenAPI component (CVSS 4.0 PR:L, confirmed by the CVSS:4.0 vector), so purely unauthenticated attack is not established by the available data. Publicly available exploit code exists - a Go proof-of-concept targeting this exact endpoint has been published on GitHub - and the vendor was contacted early but did not respond, so no vendor-released patch has been identified at time of analysis; the CVSS 4.0 base score of 5.3 is modest largely because all three impact dimensions were rated Low, whereas an independent assessment rates confidentiality impact as High (CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N).
Opening a crafted ELF binary with radare2 or rabin2 before version 6.2.0 can drive a heap out-of-bounds read in the ELF parser and terminate the process, giving anyone who can supply the file to an analyst a local denial of service (CWE-125, CVSS 3.1 5.5, AV:L/AC:L/PR:N/UI:R, C:N/I:N/A:H). The trigger is a program-header count of 0xffff (ELF's PN_XNUM sentinel) paired with a small real count in shdr[0].sh_info: the parser allocates the program-header array using the resolved count while several consumers still iterate over the original 65535 value, reading past the allocation. Exploitation requires the user to open an untrusted binary, no public exploit code or confirmed in-the-wild activity has been reported, and memory disclosure or code execution has not been demonstrated, so the practical impact is a crash of the analysis process rather than a compromise.
radare2 versions prior to 6.2.0 can leak uninitialized or adjacent heap memory into JSON output, and may crash the process, when an analyst runs the explicit pFB or pFBj print command over an attacker-supplied binary property list. The root cause is an under-allocated, non-NUL-terminated UTF-8 conversion buffer in the binary-plist Unicode parser (CWE-125, out-of-bounds read) that the JSON encoder then scans as a C string. All signals agree this is a low-priority local issue: the CVSS vector is AV:L/PR:N/UI:R with only low confidentiality and low availability impact, there is no network vector, no privilege gain, and no write or code-execution primitive; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV. Vendor-released fix: 6.2.0.
OS command injection in Moonshot AI's Kimi Code (versions 0.31.0 and earlier) lets an attacker-controlled .mcp.json file in an untrusted workspace be auto-spawned by the MCP Configuration Loader before any trust confirmation, executing arbitrary OS commands on the developer's machine. Exploitation requires the victim to open or operate on the malicious workspace (user interaction) and to run a pre-0.31.1 version; publicly available exploit code exists, but there is no confirmed active exploitation (no CISA KEV). Although the vendor rates this CVSS 4.0 at only 2.1, an independent assessment scores it 7.8 (CVSS 3.1, AV:L/AC:L/PR:N/UI:R, C:H/I:H/A:H) because CWE-78 command injection inside an AI agent's configuration loader normally yields full code execution.
Stored cross-site scripting (CWE-79) in the LightRAG WebUI prior to 1.5.5 lets an attacker who can ingest a document persist raw HTML that the query path later returns and renders as active content, executing JavaScript in the WebUI origin for any user who views the poisoned answer. The vulnerable sinks are ChatMessage.tsx, which renders answer and thinking content through react-markdown with rehypeRaw and skipHtml=false but no HTML sanitizer, and a Mermaid rendering path configured with securityLevel 'loose' that injects generated SVG via innerHTML; an attacker-supplied iframe srcdoc or crafted mermaid block is sufficient to run script. Successful exploitation lets the attacker read the API token held in the victim's localStorage and perform API actions as that user, so the assessed scope is changed (S:C) with limited confidentiality and integrity impact. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N (6.1), meaning the attacker requires authenticated ingestion capability and the victim must run a query that surfaces the content and view it in the WebUI; no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV).
Path traversal in changedetection.io 0.60.7 and earlier lets an authenticated low-privilege user read files outside the intended content directory by manipulating the filename argument handled by the static_content function in changedetectionio/flask_app.py (visual_selector_data component). Publicly available exploit code exists and the disclosure is documented by VulDB, but the maintainer did not respond, so no vendor-released patch has been confirmed; exploitation requires a valid low-privilege session (PR:L) and no user interaction. Impact is confidentiality-only - arbitrary file read with no file write, code execution, or availability effect - which keeps the CVSS 5.3 rating moderate and the value of the flaw dependent on which files the traversal can reach.
Authorization bypass in GitHub Enterprise Server allows any authenticated instance user to read the raw diff or patch of pull requests in private repositories they should not be able to access. The flaw (CWE-639) stems from raw diff/patch access tokens being scoped to a repository name and pull request number rather than a globally unique repository identifier, so an attacker who creates their own repository and pull request matching a target's name and number can reuse a token minted for their own repository to retrieve the private pull request contents. Exploitation requires a valid account on the instance, the ability to create repositories and pull requests, and knowledge of the target repository name and a valid PR number, which is why the vendor's CVSS 4.0 rating is 6.0 with AT:P and the impact is limited to confidentiality (no write or availability effect); no public exploit code has been identified at time of analysis and the issue is not in CISA KEV. All GHES versions prior to 3.22 are affected, with fixes in 3.17.21, 3.18.15, 3.19.12, 3.20.8, and 3.21.6.
Stored cross-site scripting in changedetection.io up to and including 0.55.8 lets a malicious or compromised monitored web page inject markup that is rendered in the Visual Selector UI, because the selector string is written into the DOM with innerHTML rather than as text. Exploitation requires an authenticated user who has added a page they do not control, plus that user opening the Visual Selector for the affected watch, so impact is confined to the victim's own browser session and is limited to integrity of the displayed page. Publicly available exploit code exists, but the issue is not confirmed actively exploited (CISA KEV) and independent assessment rates it low priority given the authentication and user-interaction prerequisites; upgrading to 0.60.1 resolves it.
Incorrect authorization in OpenBao releases prior to v2.6.0 lets an authenticated client bypass a more specific `capabilities = ["deny"]` rule when performing LIST or SCAN operations, exposing the names of secrets/metadata paths that policy explicitly marked as denied. The flaw only manifests in deployments that layer a trailing-wildcard deny (for example `secrets/metadata/restricted/*`) beneath a broader list/scan grant on a parent wildcard (for example `secrets/metadata/*`); read, write, delete and other operation types are unaffected, and only path/key names are disclosed, not secret values - consistent with the assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N. Vendor-released patch: v2.6.0. There is no public exploit identified at time of analysis and the issue is not in CISA KEV; overall this is a genuine but low-priority access-control flaw.
IBM Concert 1.0.0 through 3.0.0 uses weaker-than-expected cryptographic algorithms that can expose highly sensitive information to decryption by an attacker who obtains the protected data. The CVSS 3.1 vector is AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:N/A:N, so no authentication or user interaction is required per the vector, but exploitation is constrained by high attack complexity and the need to acquire ciphertext before breaking the weak cryptography. No public exploit identified at time of analysis and no CISA KEV entry were provided; a vendor patch is available via IBM support node 7288830.
Malformed ZeroMQ AUX_DATA control messages can terminate the Decode worker's control thread in SGLang 0 through 0.5.15, letting an unauthenticated attacker who can reach the Decode control PULL socket take the inference server offline. The flaw is a missing input-validation check on the control-message path (availability-only impact; no data exposure or code execution), and the assessed CVSS 3.1 vector is AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H for a base score of 5.9. Exploitation is realistic only where the Decode control socket is exposed beyond localhost in disaggregated or multi-node deployments, which is why the attack complexity is rated High; no public exploit has been identified at time of analysis and the issue is not in CISA KEV.
Server-side request forgery in the Tauri HTTP plugin (tauri-plugin-http) before http-v2.7.0 lets any host the plugin's scope allowlist permits - a host the attacker controls or one hosting an open redirect - bounce the request onward to destinations the scope explicitly denies, including cloud metadata endpoints such as 169.254.169.254, localhost services, and internal network hosts. The plugin's reqwest client follows HTTP 3xx redirects internally and the scope allowlist was only evaluated against the frontend's original URL, so the redirect target is never re-checked; the response is then returned to the webview. Rated CVSS 5.6 (assessed AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:N/A:N), it is unauthenticated but requires an attacker-influenced allowlisted origin and a frontend that actually issues the fetch; there is confirmed actively exploited (CISA KEV) status, no public exploit identified at time of analysis, and the vendor fix is opt-in.
SQL injection in the login.php authentication handler of anirbandutta9's College-Notes-Gallery lets remote, unauthenticated attackers manipulate the 'user' and 'pass' request parameters to inject arbitrary SQL into the backend query, with low confidentiality, integrity, and availability impact per the assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N). Exploitation requires only network reachability to a deployed instance exposing login.php, and publicly available exploit code exists (the disclosure was made public via the referenced GitHub issue and VulDB entries), though there is no confirmed active exploitation (CISA KEV) and EPSS data was not provided. Risk is tempered chiefly by deployment scarcity - this is an obscure open-source GitHub project with a very small install base - and by the fact that no vendor-released patch has been identified, since the vendor was contacted early but did not respond.
Opening a specially crafted file in Adobe Bridge triggers an out-of-bounds read that leaks potentially sensitive contents of the application's process memory. The flaw is local in nature - an attacker must first deliver a malicious asset and convince a victim to open it in Bridge (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N, base score 5.5) - so there is no remote or server-side exposure and no authentication requirement. Impact is limited to information disclosure (confidentiality high, integrity and availability unaffected); no public exploit code or confirmed active exploitation was identified at time of analysis, and Adobe has published advisory APSB26-148 covering the affected Bridge releases.
Server-side request forgery in Mattermost (11.7.x through 11.7.10, 11.8.x through 11.8.5, 11.9.x through 11.9.1, and 11.10.x through 11.10.1) allows an authenticated System Administrator to set the OAuth token or userinfo endpoint to an internal network address, causing the Mattermost server to issue that request because the platform's internal-connection filter is not applied to OAuth endpoint traffic, and then read the internal response back through the configured OAuth flow. Impact is bounded: the attacker must already hold the highly-trusted System Administrator role (CVSS PR:H), confidentiality and integrity effects are Low with no availability impact, and the flaw only matters where the Mattermost server has network reachability to sensitive internal services. There is no public exploit identified at time of analysis, no CISA KEV listing, and the vendor CVSS of 5.5 (Medium) is well-calibrated - this is a genuinely low-priority issue despite the CWE-918 classification. The assessment vector CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:L/A:N matches the vendor.
Unauthenticated SQL injection in Yonyou KSOA 9.0 lets remote attackers inject arbitrary SQL through the address parameter of the /cardcase/search_list.jsp endpoint, potentially reading or modifying database contents depending on the privileges of the database account the application uses. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms no credentials or user interaction are required, so any host able to reach the JSP page can attempt exploitation, and publicly available exploit code exists. There is no indication of confirmed active exploitation (not in CISA KEV), and although the vendor was contacted early about the disclosure it did not respond, so no vendor-released patch has been identified at time of analysis.
Integer overflow in Adobe's CAI Content Credentials Rust SDK and Content Credentials command-line tool crashes applications that parse a maliciously crafted C2PA/Content Credentials asset, producing a denial-of-service condition. The flaw requires no authentication (CVSS PR:N), but exploitation is gated by user interaction (UI:R) - a victim must visit a maliciously crafted URL or interact with a compromised web page that hands the crafted asset to a vulnerable parser - and the scored impact is limited to availability loss, with no code execution or data confidentiality impact. This is a genuine but low-priority issue: no public exploit identified at time of analysis, no confirmed active exploitation, and risk is confined to applications actually built on or invoking this SDK or CLI; maintainers of downstream consumers should follow Adobe advisory apsb26-147 for fixed builds.
Processing a maliciously crafted C2PA / Content Credentials asset through the CAI (Content Authenticity Initiative) Content Credentials Rust SDK or its companion command-line tool causes improper input validation (CWE-20) that terminates the application, resulting in an application-level denial of service. The flaw carries a CVSS 3.1 base score of 5.5 (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H), meaning exploitation is unauthenticated but requires the victim to actively load attacker-supplied input - for example by opening a malformed C2PA file, visiting a crafted URL, or interacting with a compromised web page that feeds the SDK. Per the independent assessment this is a genuine but low-priority issue: only a crash is achievable (no code execution, data disclosure, or integrity modification), and no public exploit code has been identified, with the issue not listed in CISA KEV. EPSS scoring was not provided in the available intelligence.
Opening a specially crafted document in Adobe InDesign Desktop drives the application into a NULL pointer dereference that terminates the process, giving an attacker a low-cost denial-of-service against a single user session. The attack is local in nature (CVSS AV:L) and requires the victim to manually open the malicious file (UI:R); per the CVSS vector PR:N, no authentication is needed, but the attacker must first deliver the file and socially engineer the user into opening it. Impact is confined to availability (C:N/I:N/A:H) - the user recovers by relaunching InDesign, possibly losing unsaved work - and there is no public exploit code or confirmed active exploitation identified at time of analysis, so this remains a genuinely low-priority issue despite its MEDIUM 5.5 rating.
Loading a crafted .yrc compiled rules file crashes YARA 4.5.8 (libyara) by driving an internal assertion to abort, giving an attacker a denial-of-service primitive against any process that parses untrusted compiled rules. The malicious file declares num_buffers=0 in its arena header, which reaches yr_arena_get_ptr() in libyara/arena.c and trips a failed assertion, terminating the host application. Exploitation is local with user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H, score 5.5) and publicly available exploit code exists per the SSVC assessment (Exploitation: poc), though no confirmed active exploitation in CISA KEV has been reported and EPSS is low at 0.20% (10th percentile). Impact is limited to availability (process crash) with no confidentiality or integrity loss and no privilege escalation.
Opening a specially crafted VRML/X3D or scene file with a GPAC-based application (GPAC 2d7da22e / 26.08-DEV) crashes the process through a NULL pointer dereference in the scene-graph cloning routine gf_sg_vrml_field_clone(), producing a denial of service. The trigger is a PROTO node whose default SFImage field has a NULL pixel source pointer, and per the assessed vector (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) exploitation is local and requires the victim to open an attacker-supplied file, with impact limited to availability - no code execution, data disclosure, or privilege gain. Publicly available exploit code exists, but there is no evidence of active exploitation (not in CISA KEV) and the EPSS score is low at 0.20% (10th percentile), so this is a low-priority availability-only issue.
Heap memory corruption and denial of service in radare2 versions prior to 6.2.0 occur when the CPython .pyc marshal parser processes a crafted bytecode file that declares a string length of 0xffffffff, wrapping the size-plus-one allocation to zero before attacker-controlled data and fill bytes are written past the heap buffer. Exploitation is local and requires user interaction - an analyst must open or inspect the malicious .pyc with r2 or rabin2 - and no privileges are needed per the CVSS vector (AV:L/PR:N/UI:R), with impact confined to corrupting or crashing the analysis process. Arbitrary code execution is possible in principle but has not been demonstrated, no public exploit code has been identified at time of analysis, and the 5.5 CVSS score reflects a genuinely low-priority issue for most environments. Only workflows that routinely open untrusted .pyc files (malware analysis, CTF, reverse-engineering) are realistically at risk.
Denial of service in radare2 prior to 6.2.0 lets a crafted NE (New Executable) binary hang the tool indefinitely by driving the relocation fixup-chain parser into an unbounded loop that allocates a fresh relocation object on every pass, exhausting CPU and memory until the process is killed or the user aborts it. The attack is local and requires the victim to open the attacker-supplied file (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H), with availability impact only and no confidentiality or integrity effect, so this is a genuine but low-urgency issue. No public exploit code was identified at time of analysis and the flaw is fixed in version 6.2.0.
Denial of service in radare2 versions prior to 6.2.0 allows an attacker to exhaust memory and processing time in the analyst's session by supplying a small crafted full-memory Windows crash dump (dmp64 format), which the 64-bit dump parser opens without validating input-controlled page counts against the actual file size. Exploitation is local and requires user interaction - a victim must open the malicious dump (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H) - and the impact is confined to availability, with no code execution or data disclosure. No public exploit code and no confirmed active exploitation were identified at time of analysis.
Loading a crafted Apple Preferred Executable Format (PEF) file into radare2 prior to 6.2.0 can consume excessive CPU and stall or hang the analysis session, because the PEF loader accepts relocation-section counts that are not validated against the number of sections or the relocation records actually present in the input. The bug is reached through normal binary-format auto-detection, so simply opening or auto-analyzing the malformed file is sufficient; the attack is local and needs user interaction (CVSS:3.1/AV:L/AC:L/PR:N/UI:R) and results only in denial of service, with no confidentiality, integrity, or code-execution impact and no network-reachable attack surface. No public exploit code or confirmed active exploitation was identified at time of analysis, and the issue is fixed in radare2 6.2.0.
Local file disclosure in ProjectDiscovery Nuclei 3.0.0 through 3.9.x lets an untrusted, unsigned workflow template read arbitrary files from the scanner host even when the operator has not enabled file-protocol templates. The workflow loading path fails to enforce the -file capability gate for file: templates referenced by a workflow, so CLI users running workflows with -w and SDK integrations that accept end-user-supplied workflows while relying on the default file-access restriction are exposed; per the CVSS vector (AV:L, PR:N, UI:R, C:H/I:N/A:N, score 5.5) an unauthenticated attacker can trigger the read only if the operator loads and runs the malicious workflow, and impact is limited to confidentiality with no code execution or data modification. No public exploit code was identified at time of analysis and there is no confirmed active exploitation; vendor-released patch 3.10.0 closes the bypass (CWE-284 improper access control).
Opening a specially crafted document in Adobe InDesign Desktop crashes the application through a NULL pointer dereference, giving an attacker a local denial-of-service against a single workstation. The flaw is rated CVSS 5.5 (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H), meaning the attacker needs no credentials but must socially engineer the victim into opening a malicious file locally; impact is limited to an application crash with no code execution, data disclosure, or integrity loss. No public exploit code or confirmed active exploitation was identified at the time of analysis, so this is a low-priority availability issue for most environments despite the MEDIUM base score - patching is still advisable to remove the crash vector and any future path to more serious memory-corruption abuse.
Unrestricted file upload in JosephChuks php-file-manager-with-code-editor through version 3.0 lets remote attackers write attacker-controlled files, including executable PHP, to the server by manipulating the filename and content arguments passed to file_put_contents in codeEditor.php's Save Handler, which can result in remote code execution wherever the write target is web-servable. The vendor's CVSS 4.0 vector indicates an unauthenticated attack (PR:N/UI:N) against the affected component, though file-manager and code-editor front ends are commonly placed behind an application login, in which case a valid session or credentials could be the real limiting factor. Publicly available exploit code exists (the disclosure was made public, and the vendor was contacted about it but did not respond); there is no CISA KEV listing and no EPSS score was provided, and the product has negligible real-world deployment.
Deleted or deprovisioned users can retain authorization on hosts running SSSD with the LDAP access provider when ldap_access_order includes ppolicy or lockout, because a user lookup that returns zero results trips a fail-open path that reports success and caches an allow decision. A remote attacker who already holds valid account context on the SSSD-managed host (authenticated, PR:L) can exploit this after offboarding to keep reading information and make limited modifications, giving low confidentiality and integrity impact (CVSS 3.1 5.4 Medium). The flaw only affects non-default access configurations that explicitly enable ppolicy/lockout ordering, and no public exploit identified at time of analysis.
Unauthenticated, network-reachable attacks against HPE Aruba Analytics and Location Engine (ALE) can degrade or knock out the service and may expose sensitive location/analytics data, with HPE reporting multiple issues bundled under CVE-2026-76716. Per the scored vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:L, no credentials and no user interaction are required, but the quantified impact is limited to low confidentiality and low availability, so this is a moderate rather than urgent priority. No public exploit code has been identified at time of analysis and there is no CISA KEV listing indicating confirmed active exploitation (CISA KEV); the realistic exposure is confined to internal/management networks where ALE is typically deployed, since it is a specialized Aruba analytics appliance that is rarely Internet-facing.
Denial of service in js-toml prior to 1.1.3 arises when load() processes attacker-controlled TOML with deeply nested arrays, deeply nested inline tables, or excessively long dotted/table-header keys, exhausting the V8 call stack and throwing a raw RangeError rather than the documented SyntaxParseError. The impact is limited to availability: applications that catch only SyntaxParseError and rethrow everything else can have a worker or process terminated, while consumers with broad exception handling are unaffected. No authentication or user interaction is required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, score 5.3), the flaw does not affect confidentiality or integrity, and there is no public exploit identified at time of analysis - vendor-released patch: 1.1.3.
An out-of-bounds read in LibreOffice's PICT image import path allows a crafted PICT image - one whose stored palette index exceeds the number of entries in its colour palette - to read memory past the end of the palette buffer, crashing the application and potentially disclosing a small amount of adjacent heap memory. Exploitation requires a victim to locally open a document or image that embeds the malicious PICT file; no authentication or non-default configuration is required because PICT import is a standard feature, and the assessed CVSS vector carries an Exploit Maturity of Proof-of-Concept (E:P), indicating proof-of-concept exploit code exists, though there is no confirmed active exploitation (no CISA KEV listing). Our independent assessment rates this as a moderate-severity, denial-of-service-oriented client-side memory-safety bug (CVSS 3.1 base 5.4-equivalent, AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H) rather than a high-priority remotely exploitable flaw.
Stack buffer overflow in LibreOffice's font subsetting path can crash the application and corrupt memory when a document containing an embedded CFF font is exported to PDF. The vulnerable routine converts CFF (Compact Font Format) glyphs to Type 1 operators during subsetting and writes them into a fixed-size stack buffer without verifying remaining capacity, so a glyph that emits many operators overflows the buffer (CWE-787). Exploitation is local and requires the victim to open an attacker-supplied document and trigger the subsetting code path (typically a PDF export); the CVSS v4.0 base score is 5.4 with PR:N and UI:P, and despite a proof-of-concept maturity rating (E:P) indicating publicly available exploit code exists, there is no confirmed active exploitation (not in CISA KEV). The most likely outcome is an application crash (VA:H) with limited confidentiality and integrity impact; headless or server-side document-to-PDF conversion services that ingest untrusted files are the highest-risk deployment mode.
Stack-based out-of-bounds write in LibreOffice's CFF font hint parser allows an attacker to corrupt memory and crash the application when a victim opens a document that embeds a maliciously crafted font. Affected are LibreOffice versions before the fix that checks the hint count against the array's actual capacity; exploitation requires the victim to open the crafted file (local vector, user interaction) and no authentication, with confirmed impact limited to a crash plus limited confidentiality/integrity effects-reliable arbitrary code execution is not demonstrated. No CISA KEV listing indicates active exploitation, but the CVSS 4.0 exploit maturity metric E:P indicates publicly available exploit code exists, so patching should be prioritized for users who handle untrusted documents.
Heap buffer overflow in LibreOffice Draw's PDF import path allows a crafted PDF to corrupt heap memory and crash the application when a victim opens or imports the document; the independent assessment rates confidentiality and integrity impact as low but availability impact as high, making denial of service the most realistic outcome. Exploitation requires local delivery and mandatory user interaction, and no authentication or non-default configuration is needed because PDF import is a standard feature. Publicly available exploit code exists per the CVSS 4.0 E:P metric, but there is no confirmed active exploitation (no CISA KEV entry); no EPSS score was provided.
Heap-based buffer overflow in LibreOffice's PDF import filter, reachable through LibreOffice Draw, can crash the application or corrupt heap memory when a victim opens a specially crafted encrypted PDF whose encryption dictionary declares a decryption-key length larger than the fixed-size key buffer the importer fills. Exploitation is local and requires user interaction (AV:L, UI:P/UI:R, PR:N per the CVSS 4.0 vector; the independent assessment is CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:H), so there is no remote or unauthenticated network trigger and only encrypted PDFs reach the flawed code path; the impact skews heavily toward availability (VA:H) with limited confidentiality and integrity effects. There is no CISA KEV listing indicating confirmed active exploitation, but the supplied CVSS 4.0 vector carries an exploit-maturity metric of E:P, meaning publicly available exploit code exists at proof-of-concept level. This is a moderate-priority memory-corruption bug, not an urgent one, because delivery requires convincing a user to open a malicious encrypted file locally.
Heap buffer overflow in LibreOffice's WMF graphics import path affects documents embedding a crafted Windows Metafile, allowing a local attacker to corrupt memory when the victim opens the file. The flaw arises in a text record that carries its own character advance widths, where the count of advance values and the text length are read independently and need not agree, so rendering walks the advance array past its end when the array is shorter than the text. No public exploit code has been identified at time of analysis, and the impact profile is crash-dominant (confidentiality and integrity Low, availability High), making realistic outcomes denial of service rather than reliable code execution. EPSS is not provided, but exploitation requires the victim to open a malicious document (AV:L, UI:P), so real-world priority is assessed as low despite the MEDIUM CVSS of 5.4.
Uncontrolled resource consumption in IBM Concert 1.0.0 through 3.0.0 allows a remote, unauthenticated attacker to degrade service availability by feeding a specially crafted regular expression through the affected input-processing path, causing excessive CPU and memory consumption. Per the CVSS vector (AV:N/AC:L/PR:N/UI:N, availability impact Low only), no credentials or user interaction are required, but the practical blast radius is bounded: only availability is affected, so expect slowdowns or partial unavailability rather than data compromise or full host takeover, and only on Concert deployments that actually expose the vulnerable input surface to untrusted traffic. No public exploit code has been identified at time of analysis and there is no indication this issue is confirmed actively exploited (CISA KEV); the vendor has published a fix advisory, making this a genuine but low-priority patching item.
Configuration information disclosure in OpenEye Apex Network Video Recorder (NVR) firmware 3.2.9.376 arises because the firmware trusts a client-supplied X-Forwarded-For header when determining the request's source address, so an unauthenticated remote attacker can spoof a loopback address such as 127.0.0.1 and defeat local-connection-only controls on the appliance's non-TLS web interfaces. Successful abuse discloses configuration information only; the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) confirms no integrity or availability impact and no authentication or user interaction requirement. The flawed design has been present since at least firmware 2.2.3.4, is fixed in 3.5.4, and no public exploit has been identified at time of analysis, consistent with this being a genuine but modest-severity issue.
Server-side request forgery in Novu prior to 3.18.0 allows an authenticated user to make the notification worker issue attacker-directed POST requests to internal or otherwise restricted network services by supplying a chat webhook URL through subscriber credentials.webhookUrl, channel endpoint.url, event payload.webhookUrl, or event overrides.webhookUrl. The Slack, Discord, Mattermost, Microsoft Teams, Grafana On-Call, Ryver, Rocket.Chat, GetStream, and Zulip chat providers pass that URL straight into raw HTTP requests in send-message-chat.usecase.ts without the normalizeOutboundHttpUrl, assertSafeOutboundUrl, or DNS-pinned safeOutboundJsonRequest guards that protect Novu's generic webhook providers, resulting in a largely blind, POST-only SSRF whose impact is bounded to interactions or actions offered by the reached internal service (CVSS 5.3; assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N). Exploitation requires a valid authenticated account and worker-level network reachability to the intended target; no public exploit code has been identified at time of analysis and there is no confirmation of active exploitation (CISA KEV). The issue is fixed in version 3.18.0.
Arbitrary filesystem writes are possible in MPXJ versions 7.3.0 through 16.4.x when an application parses an attacker-supplied Primavera P3 PRX or SureTrak STX file, because the library extracts archive entries to disk without validating that the resolved destination stays inside the intended target directory (CWE-22, a zip-slip style path traversal). The Java library and its ports (pip/mpxj, rubygems/mpxj, nuget/MPXJ.Net, nuget/net.sf.mpxj) are all affected; the CVSS vector AV:N/AC:L/PR:N/UI:N indicates unauthenticated remote exploitation, with the sole impact being integrity (attacker-chosen file writes, including overwrite of existing files reachable by the process). No public exploit code and no confirmed active exploitation were identified at time of analysis, and the real-world risk is gated by whether a consuming application exposes a PRX/STX import path to untrusted input; vendor-released patch: 16.5.0.
Unauthenticated information disclosure in the HPE Aruba Analytics and Location Engine (ALE) API allows any remote attacker who can reach the service to submit specially crafted input to a specific endpoint and retrieve sensitive user data, including password hashes, which can then be cracked or reused to pivot into other systems. No credentials, privileges, or user interaction are required (CVSS:3.1/AV:N/AC:L/PR:N/UI:N), so the only practical barrier is network exposure of the ALE API, which is typically an internal Aruba/HPE wireless location-analytics component. HPE rates the flaw 5.3 (MEDIUM) with low confidentiality impact, while our independent assessment raises the confidentiality impact to High on the same vector; no public exploit code has been identified at time of analysis and the CVE is not in CISA KEV, so this is a patch-and-segment issue rather than a confirmed active campaign.
Sensitive environment-variable disclosure in ProjectDiscovery Nuclei (versions 3.0.0 through anything before 3.10.0) allows a malicious scan target to smuggle marker-shaped response content that is reinterpreted as template syntax in a later DAST/fuzz step and resolved against the scanner's own variable map, leaking host credentials, API keys, or tokens into scan output. The flaw is an unauthenticated, network-reachable issue (CVSS:3.1/AV:N/AC:H/PR:N/UI:R) but is tightly gated on the scanner host: the operator must run a multi-step DAST or fuzz template, that template must reuse response data through an internal:true extractor, and environment-variable expansion must be explicitly enabled with -env-vars; users who do not enable -env-vars are not affected by the disclosure. No public exploit identified at time of analysis, and this is an incomplete fix for CVE-2026-41645 remediated in Nuclei 3.10.0.
Local file disclosure in ProjectDiscovery Nuclei 3.0.0 through 3.9.x lets an attacker-controlled MySQL-compatible endpoint read arbitrary files off the host running the scanner, even when the local-file sandbox (-allow-local-file-access) is disabled. The nuclei/mysql JavaScript library honors an allowAllFiles MySQL DSN option supplied by an untrusted javascript: template, so the bundled Go MySQL driver accepts LOAD DATA LOCAL INFILE requests and returns file contents to the remote server; exploitation requires an operator to run the malicious template against the attacker's endpoint (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:N/A:N, 5.3). No public exploit code was identified at time of analysis, and the vendor-released fix is version 3.10.0.
Checkmk's REST API discloses stored monitoring credentials - SNMP community strings, SNMPv3 authentication and privacy passphrases, and IPMI passwords - in cleartext inside GET responses from the host and folder configuration endpoints, even though the setup GUI never renders those secrets. The defect affects Checkmk installations below 2.5.0p15, below 2.4.0p37, below 2.3.0p51, and the end-of-life 2.2.0 line, and is reachable only by an authenticated user (CVSS vector PR:L) whose role permits viewing a target host's configuration; an anonymous or unauthenticated attacker cannot trigger it. Scoring is low (vendor CVSS 4.0 base 2.3; independent CVSS 3.1 assessment AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N), and no public exploit code or CISA KEV entry was identified at time of analysis, so the real-world risk is driven mainly by whether valuable SNMP or IPMI secrets have actually been configured on monitored hosts and by how broadly host-config view rights are granted.
Open redirect in e621ng before 26.09.16 lets remote attackers rewrite pagination and navigation links to attacker-controlled origins: query parameters named host, protocol, and port are handed to Rails' url_for, which treats them as URL-generation options rather than ordinary search filters, so the Previous/Next and numbered-page links rendered by PaginatorComponent, several controllers, and the search-trend views point at a malicious domain while the page itself still loads from the legitimate instance. No authentication is required (PR:N) and the assessed vector is AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N, so exploitation hinges on user interaction - the victim must open an attacker-supplied URL and then click a poisoned link, which is why the issue carries a modest CVSS 4.0 score of 5.3 and an assessed limited-severity rating. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis; the vendor has released a fix in 26.09.16.