Site administrators on a WordPress Multisite network can strip the two-factor authentication configuration of user accounts belonging to other sites - including accounts they are not permitted to edit - in the WP 2FA plugin before version 4.2.0, because the 2FA-removal routine is missing an object-level capability check (CWE-639). The issue is scored CVSS 2.7 (AV:N/AC:L/PR:H/UI:N/S:U/C:N/I:L/A:N) and only crosses a genuine trust boundary on Multisite installs, since single-site administrators already manage all users; publicly available exploit code exists, but there is no indication of active exploitation and EPSS is only 0.22% (12th percentile). Impact is limited to removing - not reading, forging, or bypassing inline - another user's 2FA configuration, which weakens that account's authentication posture for as long as the victim does not notice and re-enroll.
A one-byte heap out-of-bounds read in miniupnpc through 2.3.3 lets an attacker on the same local network crash a UPnP client by responding to discovery or SOAP traffic with a crafted XML element name that ends in a namespace-prefix colon. The minixml parser's parseelt function advances past the ':' character without re-checking the end-of-buffer pointer, so a single byte beyond the heap allocation is read, producing a client-side denial of service at worst. No CISA KEV listing exists, but publicly available exploit code exists (a technical write-up detailing the minixml OOB read), while the assessed impact is limited to availability loss (CVSS 3.1 AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L; vendor score 2.3 on the CVSS 4.0 scale).
miniupnpc through 2.3.3 contains a one-byte heap out-of-bounds read in the minixml parser's parseatt() routine: a malicious or spoofed UPnP Internet Gateway Device on the local network can return a crafted device description or SOAP response whose attribute list ends with an '=' character, causing the client to read one byte past the end of its buffer and crash. Publicly available exploit code exists (a detailed write-up is linked alongside the upstream fix), but there is no confirmed active exploitation; the flaw is rated CVSS 2.3 (CVSS:4.0/AV:A/AC:H/AT:P/PR:N/UI:N, low availability-only impact), so the realistic outcome is a limited denial of service for unauthenticated attackers who already share the victim's adjacent network and can spoof the gateway. No code execution or data disclosure is associated with this issue.
An out-of-bounds read in the tmfile model loader of OAID Tengine (all releases up to and including 1.12.0) allows a malformed .tmfile model to drive reads beyond the end of an allocated buffer through the offset_root argument in source/serializer/tmfile/tm2_serializer.c. Exploitation is unauthenticated but requires user interaction - the victim must load the attacker-supplied model file - so only environments that ingest models from untrusted or third-party sources are realistically exposed, and the independent assessment rates this a low-priority issue notwithstanding its public disclosure. Publicly available exploit code exists (a public GitHub issue, OAID/Tengine#1453), but there is no evidence of active exploitation and no vendor patch has been released at time of analysis; impact is bounded to low-severity information disclosure and availability effects.
Local users with low privileges can bypass the ClawScan Static scanner (clawscan-static) in OpenClaw ClawScan up to and including version 0.1.6 by supplying scan targets whose paths the tool wrongly treats as skippable, allowing content such as packaged Python bytecode to go uninspected while still being processed. The flaw is a path-classification error in shouldSkipTargetPath (internal/runner/runner.go), so the protection mechanism fails rather than being memory-corrupted, and impact is limited to low confidentiality, integrity, and availability effects (CVSS 4.0 base score 1.9; independently assessed as CVSS 3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N). Publicly available exploit code exists (a proof-of-concept scanner-bypass project) and exploitation requires the victim to actually run ClawScan against attacker-supplied content; there is no indication of confirmed active exploitation (CISA KEV), and the vendor has released a fix in version 0.1.7.
Command injection and buffer overflow weaknesses in HPE NonStop Java JToolkit can let a locally positioned, already highly privileged attacker corrupt memory or execute unintended commands within the JToolkit process, with impact limited to low confidentiality, integrity, and availability effects (CVSS 3.1 base 3.8, Low). Exploitation is not remote: it requires pre-existing high local privileges (PR:H), local access to the NonStop system (AV:L), a separate user interaction that supplies attacker-influenced input to the vulnerable routine (UI:R), and additional non-deterministic conditions captured by high attack complexity (AC:H). No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (no CISA KEV listing), so all available CVSS signals point to a low real-world priority.
Request-line injection in cpp-httplib 0.29.0 through 0.50.x lets a caller-controlled path that reaches Client::open_stream() - or any client path when set_path_encode(false) is in effect, such as a decoded redirect Location - carry raw CR/LF bytes into detail::write_request_line() and split the outbound HTTP/1.1 request line, injecting attacker-shaped request metadata that a downstream backend or intermediary may honor. The library itself requires no authentication (CVSS vector PR:N), but practical exploitation needs two coinciding conditions: the embedding application must forward remote input into that unsanitized path, and the receiving server or proxy must interpret the injected bytes as header or request boundaries. Impact is integrity-only (I:L) with no confidentiality or availability effect, no public exploit code has been identified at time of analysis, and the vendor fix is released in 0.51.0, making this a low-priority defense-in-depth issue rather than an urgent threat.
Authentication rate-limit bypass in Zimbra Collaboration Suite 10.1.0 through 10.1.21 enables remote, unauthenticated attackers to use GraphQL aliases to pack multiple password guesses into a single HTTP request without incrementing Zimbra’s source-IP failure counter, weakening brute-force and credential-stuffing protections. The flaw does not itself grant account access: successful compromise still requires guessed or stuffed valid credentials, and the independent assessment notes that valid MFA, strong unique passwords, WAF inspection of GraphQL alias abuse, or restricting portal exposure can materially reduce impact. Signals are mostly low and largely consistent, but the raw CVSS understates the operational risk; no public exploit was identified at time of analysis, though Rapid7 has published research on the issue.
Path traversal in UniFi Protect AI Key allows unauthenticated, network-reachable attackers to obtain limited information about files on the device, but exploitation requires high attack complexity and specific conditions per the vendor. No public exploit code or active exploitation has been identified at time of analysis. The CVSS score is 3.7 (Low), reflecting the difficulty of exploitation and the restricted confidentiality impact.
A path traversal write/truncate primitive in Ubiquiti's UniFi Protect AI Key lets unauthenticated attackers who already have network reachability to the device create or truncate files on it when specific, attacker-uncontrolled conditions are met. Impact is limited to integrity (CVSS 3.1 score of 3.7, AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) - no code execution, data disclosure, or availability loss is claimed - and the high attack complexity points to a required precondition such as a race condition or a particular device state. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing); Ubiquiti's Security Advisory Bulletin 070 is the authoritative reference.
FileRise deployments prior to 3.20.0 expose the /api/file/snippet.php short-text preview endpoint without the standard authenticated-session guard, allowing unauthenticated network requests to reach ACL evaluation rather than receiving an immediate 401. On default, correctly configured installations the ACL checks still block access, so arbitrary file read is not possible; actual short preview content disclosure requires an additional non-default reverse-proxy header configuration or ACL misconfiguration, making the assessed real-world risk LOW (CVSS 3.7). No public exploit identified at time of analysis.
Out-of-bounds read in Godot Engine through 4.7.2 lets a crafted .translation resource drive a hash-table offset far past the allocated bucket table in OptimizedTranslation::get_message, so that loading the resource and performing a tr() string lookup either crashes the Godot editor or an exported game or returns raw heap bytes from elsewhere in the process as the 'translated' string, disclosing process memory. Exploitation is local and requires user interaction - the crafted translation file must be delivered into the project or game and then a lookup performed against it - and reliable heap disclosure depends heavily on process memory layout, so a crash is far easier to trigger than a useful leak; there is no public exploit identified at time of analysis. The report is disputed by the supplier, which argues loading untrusted resource files sits outside Godot's current threat model, and the assessed CVSS of 3.6 (AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L) reflects a genuinely low real-world risk rather than a remote or wormable issue.
Removing two packages in a single BusyBox dpkg invocation can silently drop the second package's stanza from the dpkg status file when the first package's stanza is larger than the second, leaving the package database inconsistent with what is actually installed. Only environments that compile in and actually use the BusyBox dpkg applet are affected - Red Hat lists Red Hat Hardened Images, whose minimal footprint typically relies on BusyBox applets, and any other image built with CONFIG_DPKG enabled. The assessed vector (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N, score 3.3) requires local execution plus a human performing the removal, yields integrity-only impact on the status file with no confidentiality or availability effect, and no public exploit or code execution path has been identified at time of analysis.
Support bundles generated by talosctl on Talos Linux releases prior to 1.12.9 and 1.13.3 include the registry 'auth' field from registryconfigs.cri.talos.dev.yaml and sensitive file content from etcfilespecs.files.talos.dev.yaml without marking or redacting them, so an operator who hands such a bundle to an unintended recipient can expose private container-registry credentials and configuration secrets. The flaw is a locally triggered information-disclosure issue rated CVSS 3.3 (AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N): exploitation requires an operator to produce the bundle and deliberately share it, and the real-world impact depends on the network exposure of the leaked registry and the privileges of the exposed credentials. No public exploit code or confirmed active exploitation has been identified, and the issue is fixed in 1.12.9 and 1.13.3.
Information disclosure in the VeraCrypt Windows kernel driver (veracrypt.sys) in version 1.26.29 and earlier allows a locally authenticated, low-privileged user to supply crafted object-manager or device paths to the TC_IOCTL_GET_RESOLVED_SYMLINK, TC_IOCTL_GET_DRIVE_PARTITION_INFO, VC_IOCTL_GET_DRIVE_GEOMETRY_EX, and legacy TC_IOCTL_GET_DRIVE_GEOMETRY handlers, causing src/Driver/Ntdriver.c to perform kernel-context symbolic-link and disk-device lookups outside the intended VeraCrypt workflow scope. Successful abuse discloses only low-sensitivity metadata - drive-letter targets, partition information, disk geometry, GPT/MBR state, and limited object-manager path metadata - with no integrity or availability impact, which is why the issue carries a low CVSS 3.3 (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N). Exploitation is strictly local, requiring an interactive session or code execution as any user account on a host running an affected driver; no public exploit code identified at time of analysis, and the issue is fully neutralized on hosts updated past the upstream fixing commit.
Integer overflow (CWE-190) in the rapidcsv C++ header-only CSV parser prior to version 8.99 allows a local attacker to corrupt heap memory or crash a process that loads an attacker-supplied CSV into an in-memory matrix. The affected APIs - RemoveColumn, InsertColumn, RemoveRow, InsertRow, and GetColumnNames - cast a size_t index to int before adding it to a std::vector iterator, so on 64-bit systems an index above INT_MAX wraps negative and points before the start of the buffer. Exploitation prerequisites are severe: the process must hold a matrix with more than 2^31 elements in a row or column (tens of gigabytes of RAM) and then call one of those APIs, so ordinary CSV workloads are not practically affected. No public exploit identified at time of analysis; the CVSS base score is 2.9 (AV:L/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L), and the fix is the vendor-released patch in v8.99.
A heap out-of-bounds write in Godot Engine through 4.7.2 is reachable when the engine (or an exported game built with it) loads a specially crafted binary resource file (.res). A negative Unicode-string length field read from the file bypasses the buffer-resize check and is then sign-extended into a very large unsigned copy count, causing file-controlled data to be written far past an undersized heap allocation. The attack is local and requires the victim to open a malicious .res file in the editor or to load it at runtime in a game that ingests external assets such as mods or user-supplied content, and reliable code execution demands heap grooming (high complexity); no public exploit code and no confirmed active exploitation were identified at time of analysis. Note that the supplier disputes the security relevance, arguing that loading untrusted resource files is outside Godot's threat model, whereas independent assessment rates the confidentiality, integrity and availability impact of a successful trigger as High.
Heap out-of-bounds write in the Radiance HDR (.hdr) image decoder of Godot Engine through 4.7.2 allows an attacker-supplied .hdr file to corrupt heap memory with contents and overflow length controlled by the file, during project import or runtime image loading. The vendor's CVSS 3.1 vector places this at local, high-complexity, user-interaction-required, unauthenticated (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:L per the independent assessment), because the victim must import or load the crafted file and success depends on heap layout. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor disputes that attacker-supplied asset delivery is inside the current Godot threat model, leaving real-world priority LOW.
Authenticated Papermerge Core users can query the GET /tags/all and GET /document-types/all endpoints with a group_id parameter to read tag and document-type metadata belonging to groups they are not members of. The flaw is a missing authorization check (CWE-862) present through version 3.5.3: those routes omit the user_belongs_to membership validation, so anyone who already knows a target group's UUID receives the group's tag and document-type listings instead of a 403. Exploitation requires a valid low-privileged account plus prior out-of-band knowledge of a foreign group's UUID (CVSS 4.0 AT:P, PR:L), the impact is read-only metadata disclosure limited to low confidentiality (no document content, no writes), and no public exploit code or confirmed active exploitation has been identified at time of analysis.
Information disclosure in Dell OS Recovery Tool versions prior to 2.4.4 allows a low-privileged local account, combined with physical access to the machine and user interaction with the tool, to read sensitive information that the application stores insecurely on disk. The exposure is limited by design: the attack vector is physical (AV:P), authentication is required at the low-privilege level (PR:L), and the only impact is Low confidentiality (C:L) with no integrity or availability effect, producing a CVSS base score of just 2.2. There is no public exploit code identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV); remediation is available by upgrading to Dell OS Recovery Tool 2.4.4 or later per Dell DSA-2026-450.
Loading an untrusted safetensors model file into ExLlamaV2 up to and including 0.3.2 triggers a heap buffer overflow in the Safetensors Tensor Loader, because STFile.get_tensor in exllamav2/stloader.py acts on the data_offsets value from the model header without validating that it stays within the mapped buffer. The path is network-reachable and requires no credentials (PR:N), but it is gated by user interaction (UI:P, CVSS 4.0) - an attacker cannot hit a passive inference server, only one that is actually made to load a malicious or tampered third-party model. Publicly available exploit code exists and no CISA KEV entry is associated, so this is a proof-of-concept-driven issue rather than confirmed in-the-wild exploitation; the vendor-assessed CVSS 4.0 score is 2.1 (Low), and our independent assessment lands at a similar Low real-world priority because the realistic outcome is denial of service or limited memory corruption rather than reliable remote code execution.
An out-of-bounds write in the Whisper speech-recognition model loader bundled with Praat (external/whispercpp/whisper.cpp) is triggered when a user loads a crafted Whisper model whose tensor dimension count (n_dims) falls outside the expected 0-4 range, corrupting memory on the local system. Affected versions are Praat up to and including 7.0.02; exploitation requires user interaction - the victim must actively open the malicious model file - and no authentication is required, with impact limited to low confidentiality, integrity, and availability loss on the local host. Publicly available exploit code exists, but the issue is rated low priority given the local attack path and the required user action, and no data indicates confirmed active exploitation.
Denial of service in sgl-project SGLang up to 0.5.19 allows remote attackers to crash request handling by submitting a malformed session_params object to the generate endpoint, where a field such as id, rid, offset, replace, or drop_previous_output is supplied with the wrong data type. Because SessionParams is constructed without type validation in vulnerable builds, the mismatched type raises an uncaught TypeError that aborts the affected request path; no data exposure or code execution results. Publicly available exploit code exists (a reproduction script is linked in the references) and the vendor was reportedly notified via an issue but had not responded at the time of disclosure; the issue is low severity (CVSS 2.1/3.1 score of 2.1 with A:L, E:P) and affects availability only.
Reflected cross-site scripting in ClipBucket v5 (through 5.5.3-#206) allows an attacker to have arbitrary HTML and script executed in the origin of the admin panel by luring a logged-in administrator into submitting a forged cross-site POST to admin_area/index.php with mode=add_todo and a malicious val parameter; the endpoint carries no CSRF token, and the val value is echoed back through nl2br() without output encoding. The attacker requires no authentication of their own (PR:N in the published CVSS 4.0 vector), but exploitation is not self-executing: it depends on an active administrator session and on that admin being convinced to submit the crafted request (UI:A), and the consequence is script execution inside the admin panel origin rather than direct server compromise. No public exploit code was identified at time of analysis and there is no evidence of active exploitation; scoring is low (CVSS 4.0 base 2.1; independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N), making this a genuinely low-priority finding whose risk is bounded by the required victim interaction and privileged session.
Heap- and stack-based buffer overflow in HPE NonStop Hpjmeter, the Java-based performance/profiling analysis client for HPE NonStop systems, can crash the tool when it parses crafted input. Impact is confined to availability (CVSS 3.1 base score 2.0 on the vendor's published vector, assessed as A:L with no confidentiality or integrity effect), and exploitation is gated by high attack complexity and the requirement that a privileged, authenticated user open or process the malicious data - no public exploit has been identified at time of analysis. The published vector nominally claims AV:N, but the behavior described (data/file parsing by a client tool) suggests a local delivery path; this discrepancy is unconfirmed and should be validated against HPE advisory hpesbns05148en_us.
An off-by-one stack out-of-bounds write in Mini-XML 4.0.0 through 4.0.6 lets an attacker who can supply crafted XML corrupt or crash a parsing application, but only when the host process runs under a locale whose decimal separator is not '.'. Supplying a REAL value of exactly 63 digits immediately followed by '.' drives mxml_strtod()'s decimal-point substitution logic to write a NUL byte one position past its 64-byte stack buffer (CWE-193), corrupting adjacent stack memory. No public exploit identified at time of analysis; independent assessment rates this CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:L (CVSS 4.0 base score 2.0), so all available signals point to a low real-world priority.
Palo Alto Networks PAN-OS can be driven into a denial-of-service condition by an authenticated user holding the read-only administrator role, who triggers the fault by sending a specially crafted API request to the management web interface. Only PAN-OS is affected; Cloud NGFW, Panorama, and Prisma Access are explicitly stated by the vendor to be unaffected. The impact is availability-only and low severity (vendor CVSS 4.0 score 1.2; independent assessment CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L), and the DoS is automatically recoverable, meaning the device returns to service without manual intervention. No public exploit code has been identified at time of analysis, and the vulnerability is not in CISA KEV.
Stored cross-site scripting in the Palo Alto Networks PAN-OS management web interface allows an authenticated administrator with high privileges to persist a JavaScript payload that executes when another administrator views the affected page. This is a low-severity issue (vendor CVSS 1.1; independent assessment CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:L/I:L/A:N), requiring a second admin's interaction and affecting PAN-OS on PA-Series and VM-Series firewalls and Panorama (virtual and M-Series); Cloud NGFW and Prisma Access are not affected. Vendor patches are available, and no public exploit was identified at time of analysis.
Server-side request forgery in Palo Alto Networks Checkov by Prisma Cloud before version 3.2.533 allows a local unauthenticated attacker to induce the tool to make unauthorized network requests from the host to internal services. The attacker must influence Infrastructure-as-Code content parsed by Checkov, and a victim must run a scan on a host with network reachability to the target services; it is not remotely triggerable. No public exploit code has been identified, and the impact is limited to low-severity SSRF without confidentiality or integrity impact on the Checkov host itself, though other systems may experience low confidentiality impact. A vendor patch is available in version 3.2.533.
SSH host-key verification that the user explicitly requested is silently dropped by the curl command-line tool when an SFTP or SCP transfer is reached by following an HTTPS redirect, so `--knownhosts`, `--hostpubsha256`, and `--hostpubmd5` never take effect on that connection. Only the opt-in combination of `--location` plus `--proto-redir +sftp` starting from an HTTPS URL is affected, and an attacker must additionally control the HTTPS response (to inject `Location: sftp://...`) and hold an in-path position to impersonate the SSH host - the bug degrades a requested security control rather than providing code execution or data access by itself. The independent assessment scores this CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:N (Medium severity, unauthenticated but requiring user interaction), and no public exploit identified at time of analysis.
An out-of-bounds read in curl when built with the GnuTLS TLS backend and WebSocket support allows a malicious WebSocket server to cause the client to send memory beyond its send buffer, potentially disclosing limited process memory (C:L) and causing a low availability impact (A:L). This unauthenticated attack (PR:N) requires user interaction (UI:R) because the victim must connect to an attacker-controlled WebSocket server; affected builds are those using GnuTLS rather than OpenSSL and with WebSocket support enabled, which is experimental and off by default in many distributions. No public exploit code or CISA KEV listing was identified at time of analysis, and no CVSS, EPSS, or POC data was provided, so quantitative exploitation signals are absent; a vendor patch is available per the Ubuntu security notice USN-8927-1.
Information exposure in libcurl allows an application that reuses the same curl easy handle to leak an AWS4-HMAC-SHA256 Authorization header to an unrelated subsequent URL after CURLOPT_AWS_SIGV4 is set to NULL with the expectation that SigV4 signing is disabled. This is a low-to-moderate risk state-leak defect, not remote code execution or a high-severity flaw; the assessed vector is CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N, indicating high attack complexity and limited confidentiality impact. No public exploit identified at time of analysis.
libcurl and the curl command-line tool can silently reuse an existing pooled connection for a later transfer when the requested source binding changes, so traffic that asked to egress from a different interface, host address, or IP instead leaves from the earlier transfer's source address. The defect affects applications that set CURLOPT_INTERFACE (or use curl's --interface option) with the documented if!, host!, or ifhost! prefixes and then issue multiple transfers to the same destination host and port that are eligible for curl's connection-reuse pool, with at least two of those transfers requesting different source bindings. The assessed vector (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:N) frames this as a local library logic error with low confidentiality impact rather than a remotely reachable flaw, and no public exploit code or CISA KEV listing has been identified at time of analysis.