Out-of-bounds write in Apple's iOS, iPadOS, and macOS file-parsing code lets remote attackers achieve arbitrary code execution when a victim opens a maliciously crafted file, scoring CVSS 8.8 (AV:N/AC:L/PR:N/UI:R, CWE-787). Apple fixed the flaw in iOS 26.7.1, iPadOS 26.7.1, macOS Sequoia 15.8.1, and macOS Tahoe 26.7.1, and states it is aware of a report that the issue may have been exploited in an extremely sophisticated attack against specific targeted individuals on versions of iOS before iOS 27. No public exploit code has been identified at time of analysis, and CISA's SSVC assessment records an exploitation value of 'none' with the attack assessed as non-automatable.
An unauthenticated OS command injection in the CGI handler of Netcore NR289-GE firmware 1.4.5102 lets remote attackers execute arbitrary shell commands on the router by supplying a crafted ntp_ip value to /set_ntp_server_ip.cgi. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N, VC/VI/VA:H) confirms no privileges or user interaction are needed, and the only real precondition is network reachability to the device's web management interface, so risk is highest where that interface is exposed to the WAN. Publicly available exploit code exists (linked from the VulDB disclosure and hosted on GitHub), but there is no CISA KEV entry, so active exploitation is not confirmed; the vendor was contacted and did not respond, and no vendor-released patch has been identified at time of analysis.
Missing authorization in Netcore NBR100V2 firmware 1.3.240614.030928 allows remote unauthenticated attackers to modify device configuration via the uci.apply function, as the /usr/share/rpcd/acl.d/unauthenticated.json ACL incorrectly grants this function to unauthenticated callers. Publicly available exploit code exists, and the vendor has not responded to disclosure attempts, so no vendor-released patch is identified at time of analysis. The primary exploitation barrier is network reachability to the router's rpcd/ubus management interface, which is typically LAN-bound unless exposed to the WAN.
Unauthenticated network attackers can bypass authentication in the Netcore NR289-GE router's boa_temp web handler and abuse its process_request function to write arbitrary files, leading to full device compromise with high confidentiality, integrity, and availability impact (CVSS 4.0 score 9.3, CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). The flaw affects firmware version 1.4.5102, and publicly available exploit code exists - a GitHub proof-of-concept demonstrating unauthenticated arbitrary file write against the NR289-GE V1.4.5102 web interface. No CISA KEV listing was provided; the vendor was contacted early but did not respond, and no vendor patch has been identified at time of analysis.
Remote unauthenticated OS command injection in Netcore NR289-GE firmware 1.4.5102 allows attackers to execute arbitrary commands on the router via the 'mac' parameter of the /location_time.cgi Location Time Handler. Publicly available exploit code exists, and the vendor did not respond to disclosure, so no patch is available at this time. The primary limiting factor is exposure: the web management interface is typically LAN-facing by default, so internet-wide exploitation depends on remote management being exposed to untrusted networks.
Unauthenticated OS command injection in the Netcore NR289-GE router (firmware 1.4.5102) lets any remote attacker who can reach the device's /ap_ip.cgi CGI handler execute arbitrary shell commands on the underlying operating system, with CVSS v4.0 scored 9.3 and all three impact metrics (confidentiality, integrity, availability) rated High. No authentication or user interaction is required - stated by the CVSS vector PR:N/UI:N and confirmed by our independent assessment of CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H - so the only prerequisite is network reachability of the router's web service, which is LAN-bound by default but internet-facing whenever remote administration is enabled. Publicly available exploit code exists (a detailed proof-of-concept for the ap_ip command injection is published in a public GitHub repository), and the vendor was contacted but did not respond, so at the time of analysis there is no vendor fix and the practical exposure is limited only by how widely each deployment exposes the management interface.
A stack-based buffer overflow in the devdiscover service of FAST FAC1900R firmware 20190827_2.0.2 lets unauthenticated remote attackers corrupt stack memory by sending a crafted message to the copy_msg_element function, with high impact on confidentiality, integrity, and availability. The flaw is remotely reachable with no privileges or user interaction required (CVSS:4.0 base 9.3; independent assessment of 3.1/AV:N/AC:L/PR:N/UI:N with C:H/I:H/A:H), and publicly available exploit code exists, so any deployment where the service is reachable - typically LAN-adjacent, or WAN-exposed if the device forwards the service externally - is at risk. Exploitation is not confirmed as active (no CISA KEV entry), and the vendor was contacted early but never responded, so no official patch has been identified.
Unauthenticated OS command injection in the Netcore NBR200V2 router's Web Management Interface (firmware 1.3.241127.071246) allows remote attackers to execute arbitrary operating-system commands on the device by sending a crafted QUERY_STRING to /www/cgi-bin/network_tools, where the eval handler passes the attacker-controlled value into a shell command without sanitization. The CVSS 4.0 base score is 9.3 with full confidentiality, integrity and availability impact, and the assessed CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) confirms the attack is network-reachable with no authentication and no user interaction. Publicly available exploit code exists, including a published proof-of-concept write-up on GitHub, but there is no confirmed active exploitation in CISA KEV; the vendor was contacted early about the disclosure and did not respond, so no vendor patch is available.
Archive extraction in the Node.js decompress package allows a crafted archive containing chained symlink entries to resolve file writes outside the intended output directory, because the default decompress(input, output) API relies on lexical path containment checks that the kernel's symlink resolution can bypass. This affects @xhmikosr/decompress before 10.2.2 and before 11.1.4, and the separately maintained but unmaintained kevva/decompress package through 4.2.1, which remains unpatched. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:N, 9.1) indicates unauthenticated remote triggering with high confidentiality and integrity impact; writing outside output can overwrite startup scripts or configuration and escalate to remote code execution, and the flaw is a bypass of the incomplete hardening previously applied for CVE-2026-53486. Exploitation requires the consuming application to extract an attacker-influenced archive on a non-Windows platform (Windows emulates symlinks via hardlinks and does not follow the affected path), and no public exploit code was identified at time of analysis, though the upstream fix ships a regression test that documents the escape technique.
Forged HS256 JSON Web Tokens can be accepted as authentic by PyJWT (pip package PyJWT) versions 2.13.0 through 2.13.x when an application verifies tokens through the PyJWK or PyJWKSet path and its trusted JWK Set already contains a symmetric oct entry with an empty key value ({"kty":"oct","k":""}), an unusual precondition typically caused by a missing Base64URL configuration or secret-manager value. Because the PyJWK verification path passes the decoded zero-length key straight to the HMAC check instead of running it through HMACAlgorithm.prepare_key, unauthenticated remote attackers (CVSS PR:N) who know this pre-existing misconfiguration can independently compute HMAC-SHA256(b"", signing_input) and mint valid tokens carrying arbitrary authenticated claims, giving high confidentiality and integrity impact. Public proof-of-concept exploit code exists, but the issue is not in CISA KEV, EPSS is low at 0.18% (6th percentile), and the independent assessment rates attack complexity as High rather than Low, so the headline CVSS 9.1 overstates real-world urgency; the vendor-released patch is version 2.14.0 (commit f91ed44dd65baaf457f4b3353ed35e98a753934c).
Command injection in the Ziroom ZHOME A0101 smart-home gateway (firmware 1.0.1.0) lets an attacker who already holds an administrative session execute arbitrary shell commands via the 'ip' argument of the /api/ZRQos/set_online_client endpoint, delivering high impact to confidentiality, integrity, and availability. Publicly available exploit code exists, but exploitation is gated by the high privileges required (CVSS 4.0 PR:H) to reach the endpoint remotely over the network with no user interaction. The vendor was contacted early about the disclosure and did not respond, so no patched firmware has been identified at time of analysis.
OS command injection in the Ziroom ZHOME A0101 smart-home device (firmware 1.0.1.0) allows an attacker who can reach the device's HTTP management API to execute arbitrary shell commands on the device by passing crafted shell metacharacters in the login_pwd argument of the /api/ZRnetwork/firstSetup_wifi endpoint. The vendor CVSS 4.0 vector (8.5, AV:N/AC:L/AT:N/PR:H/UI:N, with High confidentiality, integrity and availability impact plus changed scope) indicates that per the scoring model high privileges are required, although the independent assessment notes that because this is a first-time-provisioning endpoint the real privilege barrier may be weaker in practice and should be verified. Publicly available exploit code exists (a GitHub proof-of-concept), exploitation requires no user interaction, and no vendor patch is available because Ziroom did not respond to the disclosure.
Command injection in the Ziroom ZHOME A0101 smart home gateway (firmware 1.0.1.0) lets an authenticated, high-privileged remote attacker execute arbitrary shell commands on the device via the password1 parameter of the /api/ZRnetwork/set_passwd endpoint. The CVSS 4.0 vector scores 8.5 (AV:N/AC:L/AT:N/PR:H/UI:N, VC/VI/VA:H), and the high-privilege prerequisite (PR:H) is the key limiting factor, since an attacker must first hold elevated API access to reach the endpoint. Publicly available exploit code exists for this exact endpoint, raising the practical risk, and because the vendor did not respond to disclosure there is no vendor-released patch; no confirmed active exploitation (CISA KEV) has been observed.
Command injection in Ziroom ZHOME A0101 firmware 1.0.1.0 allows an authenticated attacker with high privileges to execute arbitrary shell commands on the device by supplying a crafted 'mac' value to the /api/ZRQos/set_online_client API endpoint. The flaw is network-reachable (CVSS 3.1 AV:N/AC:L) and carries full confidentiality, integrity, and availability impact on both the vulnerable device and downstream systems, though the PR:H rating means the attacker must first hold administrative access to the ZHOME management interface. Publicly available exploit code exists (a technical write-up is hosted on GitHub), but there is no indication of confirmed active exploitation, and the vendor has not released a fix.
Remote command injection in the Ziroom ZHOME A0101 smart-home device (firmware 1.0.1.0) lets an attacker who can reach the /api/ZRnetwork/firstLogin HTTP endpoint inject shell metacharacters through the 'firstLogin' parameter and execute arbitrary operating-system commands with the privileges of the underlying service. Publicly available exploit code exists (a proof-of-concept write-up is published on GitHub and the issue was reported via VulDB), and the vendor was contacted early but never responded, so no vendor patch is available. Scored 8.5 (CVSS 4.0 base, E:P) and assessed as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H by our analysis; exploitation requires the device to be network-reachable, typically on a LAN or an exposed management interface.
Command injection in the USB Device Management API (pop_usb_device) of the Ziroom ZHOME A0101 smart-home hub running firmware 1.0.1.0 lets a remote attacker who already holds administrator credentials execute arbitrary operating-system commands on the device by manipulating the 'path' argument. Publicly available exploit code exists (published with a write-up, and a PoC linked by VulDB), but there is no indication of confirmed active exploitation (not in CISA KEV). The practical exposure is gated by the need for a valid high-privilege admin session against the hub's LuCI web interface, which tempers the high CVSS 4.0 base score of 8.5.
Unauthenticated remote stack-based buffer overflow in the Netcore NR289-GE router (firmware 1.4.5102) lets an attacker corrupt memory in the boa web server's pre-authentication password-check routine by manipulating the Username argument, with high impact to confidentiality, integrity, and availability consistent with remote code execution. Publicly available exploit code exists, and the vendor did not respond to disclosure, so no vendor patch is available. Risk is highest where the device's HTTP administration interface is reachable beyond a trusted LAN, such as when remote management is enabled on WAN.
Stack-based buffer overflow in the devdiscover service of the FAST FAC1200R router running firmware 5.0_20201119_1.0.2 allows an attacker who can reach the device-discovery endpoint to overwrite stack memory with a crafted advertisement frame, with the assessed impact being full loss of confidentiality, integrity and availability (remote-code-execution class, CWE-121). Publicly available exploit code exists and the vendor was contacted but did not respond, so no vendor patch has been identified at time of analysis. The vendor-supplied CVSS 4.0 vector specifies PR:L, so some level of privilege or authentication is presumed to be required even though the advisory text does not confirm the exact prerequisite, and no CISA KEV entry indicates that this is currently being exploited in the wild.
Stack-based buffer overflow in the MmtAtePrase parser of the twlantask component on FAST FAC1200R routers running firmware 5.0_20201119_1.0.2 allows an attacker who already holds valid credentials for the device management interface to send crafted input that overwrites stack memory, with the potential for arbitrary code execution or device crash/reboot. Exploitation is network-reachable but gated by authentication (CVSS PR:L) and by the fact that this router's management interface is normally LAN-only, so WAN-side attacks depend on non-default remote-management configuration. A publicly available exploit exists (published proof-of-concept code referencing the twlantask MmtAtePrase overflow), and the vendor was contacted but did not respond, so no vendor patch is available; the flaw is not known to be actively exploited in the wild. The vendor score of 8.6 overstates real-world risk given the narrow affected build, the sub-brand's limited deployment base, and the authentication prerequisite.
OS command injection in the Netcore NBR200V2 wireless router (firmware 1.3.241127.071246) lets an authenticated, low-privilege user execute arbitrary shell commands on the device by manipulating the 'url' argument passed to the Tools Ping Handler in /usr/bin/network_tools. Exploitation is network-reachable, requires no user interaction, and publicly available exploit code exists (a proof-of-concept write-up is hosted on GitHub), so any NBR200V2 whose management/diagnostics interface is reachable and whose credentials are known, guessable, or left at default should be considered at immediate risk. The vendor was contacted early but did not respond, and no fixed firmware has been identified, so no CISA KEV active-exploitation entry is associated with this issue at time of analysis. Successful exploitation yields full compromise of confidentiality, integrity, and availability on the device itself.
OS command injection in the TOTOLINK N150RT SOHO router (firmware 3.4.0-B20201030) lets an attacker who can reach the Web Management Interface and has at least low-privilege credentials execute arbitrary operating-system commands on the device. The flaw is reachable through the /boafrm/formWlSiteSurvey handler, where the 'wlanif' argument is passed unsanitized into a shell command, giving full compromise of confidentiality, integrity and availability (CVSS 4.0 base 8.6; independent assessment maps this to CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Publicly available exploit code exists (a reference gist is tagged as an exploit), meaning the technique is already in circulation, but the issue is not confirmed actively exploited (no CISA KEV entry) and it is privilege-gated: the router web interface is normally LAN-facing, so WAN reachability depends on remote administration being enabled.
Stack-based buffer overflow in the D-Link DI-8400 router (firmware 16.07) allows a high-privileged, authenticated remote attacker to corrupt memory and potentially achieve code execution on the device by supplying a manipulated 'opt' argument to the menu_nat_more.asp endpoint handled by the menu_nat_more_asp function. The flaw is remotely reachable with low attack complexity and no user interaction, but exploitation requires valid admin-level credentials (CVSS PR:H) plus network reachability of the Web Administration Service, which is normally confined to the LAN unless remote management is enabled. Publicly available exploit code exists - a Python PoC and a technical write-up are published on GitHub - but there is no confirmation of active exploitation (no CISA KEV listing), and only firmware 16.07 is confirmed affected.
OS command injection in aaPanel/BaoTa versions up to 11.8.0 allows an authenticated attacker with access to the administrative interface to execute arbitrary operating system commands on the underlying host by manipulating the Password argument during a database backup operation. The vulnerability requires user interaction to trigger the backup workflow, but because aaPanel typically runs with root privileges, successful exploitation leads to full host compromise. A public exploit has been disclosed and may be used, though there is no confirmed active exploitation (CISA KEV) at this time.
Improper validation in PyJWT 2.1.0 through 2.14.0 allows an attacker who already holds a stolen sender-constrained (DPoP-bound) access token to replay it without possessing the legitimate holder's private key, because OKPAlgorithm.from_jwk imports an Ed25519/Ed448 private JWK from the d parameter without checking that the public key derived from d matches the declared x. An attacker-supplied JWK that pairs the victim's x with the attacker's own d therefore satisfies RFC 7638 thumbprint binding (cnf.jkt) while all signing operations use the attacker's key. Publicly available exploit code exists (a public gist reproducer), but EPSS is only 0.14% (3rd percentile) and there is no KEV listing - this is a conditional, integration-dependent flaw rather than a default-configuration remote compromise, and standard signature-verification use of PyJWT with trusted server-side keys is not affected.
Remote unauthenticated denial of service in Eyeplus 57.0.0.0308 p2pcam HTTP parser allows an attacker who can reach the camera's HTTP/P2P service to crash the device by sending an over-long URI, exploiting a stack-based buffer overflow (CWE-121). Publicly available exploit code exists; CISA KEV does not list this CVE in the provided data, so it is not confirmed actively exploited. The vendor CVSS 4.0 score is 7.7 with PR:N/UI:N and only availability impact (VC:N/VI:N/VA:H), and the independent assessment likewise rates it as a denial-of-service flaw rather than code execution.
Authentication bypass in the LiteLLM proxy lets any party who already holds a valid JWT issued by the configured external identity provider impersonate an existing user - including accounts with proxy_admin privileges - by presenting a token whose unverified email claim matches the victim's address. The JWT authentication flow performs an email-based fallback lookup without validating the email_verified claim, so the attacker inherits the victim's role and can permanently overwrite the victim's stored identity binding, retaining persistent access to administrative endpoints that expose API keys and user management. The attacker must possess a legitimately signed token from the same IdP (CVSS PR:L, AC:H), deployments that do not use JWT/IdP authentication are unaffected, and publicly available exploit code exists; no confirmed in-the-wild exploitation has been reported.
A remote, unauthenticated denial-of-service condition in the NestJS (Nest) microservices framework lets an attacker crash a service on demand by sending a single message whose 'pattern' field is a deeply nested object. Only deployments using the TCP transport (ServerTCP) or the RabbitMQ transport (ServerRMQ) are exposed, because those paths pass a client-controlled, non-string pattern into JSON.stringify to compute the handler lookup key; sufficient nesting throws 'RangeError: Maximum call stack size exceeded', and the unhandled promise rejection terminates the Node.js process under default behavior. Affected versions are prior to 11.2.4 and prior to 12.0.2; the CVSS 3.1 score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) reflects pure availability loss with no confidentiality or integrity impact, and no public exploit has been identified at time of analysis. Risk is highest where the raw TCP port or consumed RabbitMQ queue/exchange is reachable by untrusted parties, since these are typically internal service-to-service surfaces.
Denial of service in PyJWT 2.9.0 through 2.13.0: a single malformed RSA JWK embedded in a JWK Set aborts construction of the entire set, causing authentication failures or request-level outages for applications that rely on that key set. The root cause is PyJWKSet's per-key error-skipping logic, which only catches PyJWTError and therefore misses the plain ValueError raised by RSAAlgorithm.from_jwk when an RSA key supplies d/e/n with an incorrect private exponent and omits the CRT parameters. The issue is remotely reachable without authentication or user interaction (CVSS 7.5, AV:N/AC:L/PR:N/UI:N, availability-only), publicly available exploit code exists (no confirmed active exploitation), EPSS is low at 0.35% (26th percentile), and the vendor-released patch is version 2.14.0.
Deeply nested brace patterns cause unbounded recursion in the npm brace-expansion library, exhausting the native stack and terminating the Node.js process (CWE-400). All versions prior to 1.1.20, 2.1.6, 3.0.8 and 5.0.11 are affected, and the trigger is remote and unauthenticated (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) whenever an application passes attacker-controlled input into expand()/expand_() - directly or transitively through minimatch or glob. A payload of roughly 3,100 stacked '{' followed by 'a,b' and matching '}' (about 6KB) is sufficient, and because the stack is consumed before any output is generated, neither the max nor maxLength output bounds prevent the crash; no public exploit code has been identified at time of analysis and the issue is not in CISA KEV, though its availability-only impact and deep embedding in the JavaScript toolchain make it relevant to any service that expands untrusted glob or path patterns.
Stack exhaustion in the npm library brace-expansion (all versions prior to 1.1.19, 2.1.5, 3.0.7, and 5.0.10) lets a crafted brace pattern terminate the Node.js process, a process-terminating denial of service. The flaw is reachable by remote, unauthenticated attackers (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) whenever an application passes attacker-controlled strings into expand(), most commonly indirectly through minimatch or glob pattern matching of user-supplied glob or filter expressions. No public exploit code has been identified and the issue is not listed in CISA KEV, but the consuming application must expose a path to brace expansion for the bug to be reachable, so the practical risk depends entirely on how the library is embedded.
Unauthenticated denial of service in the PyJWT Python library (versions 2.0.0a1 through 2.14.0) allows a remote attacker to crash the calling application's authentication handler by supplying a JWT whose payload is valid JSON but nested roughly 20,000 levels deep. The vulnerable code paths - PyJWKClient.get_signing_key_from_jwt(), the documented JWKS verification flow, and any jwt.decode(token, options={"verify_signature": False}) call - parse the attacker-controlled payload with json.loads before any signature check, and a catch clause that handles only ValueError lets RecursionError escape as an undocumented exception (CWE-248), producing an HTTP 500 or dead worker with no credentials, valid signature, user interaction, or JWKS network lookup required. Publicly available exploit code exists (a PoC gist is referenced in the advisory data) and CISA's SSVC assessment rates the issue as automatable with partial technical impact; EPSS is low at 0.29% (20th percentile) and there is no indication of confirmed active exploitation. Impact is confined to availability - no data exposure, integrity loss, or code execution.
The JavaScript library ip-address (npm) fails to treat the NAT64 local-use prefix 64:ff9b:1::/48 as private, so applications that lean on Address6.isPrivate - typically together with isLoopback and isLinkLocal - to enforce an SSRF or trust-boundary policy can be tricked into reading an internal IPv4 destination as external. Unauthenticated network attackers can exploit this (CVSS v4.0 6.9; independent assessment CVSS v3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:N/A:N) only when the target server's network actually uses an operator-chosen NAT64 prefix carved from the RFC 8215 local-use range, and only when the consuming application composes these classifiers as a security control; information disclosure is the realistic outcome, with no impact on integrity or availability. Versions 10.2.0 through 10.5.0 are affected and the issue is fixed in 10.5.1; no public exploit code or confirmed active exploitation was identified at time of analysis, and exploitation is further gated by the non-default NAT64 deployment and by the application's use of these methods for enforcement.
Unauthenticated SQL injection in the SPS-Suite WordPress plugin through version 1.4.0 allows remote attackers to extract sensitive data from the WordPress database when the plugin's static-page search feature is enabled. The vulnerability requires that specific search feature to be explicitly activated, which narrows the exposed population, but publicly available exploit code exists and no authentication or user interaction is needed once the feature is on. CISA's SSVC framework rates exploitation as none and the attack as not automatable, and there is no confirmed active exploitation (CISA KEV status: no); the primary risk is confidentiality impact, with no integrity or availability effects.
Authorization bypass in the @grpc/grpc-js-xds package (the xDS/RBAC extension for @grpc/grpc-js) lets a request for one gRPC method be evaluated against a different method's access rule when case-insensitive path matching is enabled. Only deployments that use xDS-driven RBAC with case-insensitive matching and that define two methods where one name is a string prefix of the other (with differing access rules) are reachable; the flaw yields improper authorization with limited confidentiality impact and high integrity impact (CVSS 6.5, AC:H, PR:N). No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor patches ship in versions 1.13.1 and 1.14.1.
Unauthenticated shortcode injection in WPForms Lite (versions 1.5.0.1 through 2.0.2) lets remote attackers execute arbitrary registered WordPress shortcodes by submitting form field values that the plugin echoes back into the rendered form without stripping shortcode delimiters. Publicly available exploit code exists via the WPScan advisory, and the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N (6.5 Medium) confirms low-complexity, no-user-interaction exploitation. Impact is bounded by the shortcodes present on the target; successful exploitation can disclose attachment details of non-public posts and modify rendered form output, but does not by itself grant full remote code execution.
SQL injection in the Post Voting System WordPress plugin through version 1.0 allows an authenticated user to inject arbitrary SQL into a database query because an input parameter is neither sanitized nor escaped before use. Any low-privilege account (PR:L per the assessed CVSS vector) is sufficient, so on sites with open user registration the issue is practically reachable at scale, though exploitation is limited by the plugin's niche deployment and by the fact that a valid authenticated session is mandatory. Publicly available exploit code exists, but there is no confirmed active exploitation (SSVC Exploitation: none), so this should be treated as a genuine but modest-severity issue requiring prompt patching rather than emergency response.
Cross-family subnet comparisons in the ip-address npm library (all versions before 10.7.1) can cause isInSubnet and isHostInSubnet to report that an address falls inside a range it does not belong to, allowing an allowlist or denylist decision built on those predicates to misclassify an out-of-scope address as trusted. The flaw is a logic/comparison error (CWE-697) rather than a memory-safety issue: masked binary strings are compared without first confirming that the address and the subnet share the same IP family, so an IPv4 address checked against an IPv6 mask (or vice versa) can compare equal when the leading masked bits align. Exploitation requires a consuming application to use these methods as a security gate and to pass attacker-influenced addresses into a cross-family check; no public exploit code was identified at time of analysis, and the weakness is inert in applications that never use these predicates or that normalize IP family before comparison. Impact is bounded to integrity of the containment decision (no confidentiality or availability effect), and the vendor's CVSS 4.0 score of 6.3 is higher than our assessed CVSS 3.1 vector of AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N because practical exploitation is gated by how the host application wires these predicates.
Denial of service in the ip-address JavaScript/npm library (all versions prior to 10.7.1) lets remote attackers stall or crash a Node.js process by supplying megabyte-scale strings to the IPv6 parsing paths - the Address6 constructor, Address6.isValid, and the underlying parse routine in src/ipv6.ts. An application is only exposed if it accepts an attacker-controlled field of roughly 16 MiB or more and passes it to those entry points without an earlier length bound; common URL, HTTP header, and default body-parser limits keep inputs well below the ~32 MiB needed to terminate the process, so default configurations typically exclude the impact and this is assessed as a low-to-moderate real-world risk that does not warrant emergency prioritization. No public exploit code has been identified at time of analysis, the issue is not listed in CISA KEV, and a vendor-released patch in version 10.7.1 resolves it.
Authenticated operator-level users of Zoho ManageEngine DDI Central 6.2.0 (builds below 6201) can inject content into the Keepalived configuration through the High Availability (HA) configuration workflow, which under the right conditions escalates to arbitrary command execution as root on the DDI Central host. The flaw is network-reachable and low in complexity (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8), but it is gated by a mandatory valid operator credential and by the HA/Keepalived feature being present and configurable, so it is not pre-authentication and not self-propagating. No public exploit code or confirmed in-the-wild exploitation has been identified at time of analysis, and the vendor has published a security advisory at https://www.manageengine.com/dns-dhcp-ipam/security-updates/cve-2026-12269.html.
Arbitrary file write as root in Canonical LXD 4.0 and later (before 4.0.14, 5.0.10, 5.21.8 and 6.10) on Linux lets an authenticated client with permission to create instances or custom storage volumes in a project - or a malicious migration source server - plant a symlink inside a transferred volume and then write through it to any path on the target host, resulting in full host compromise. Exploitation requires triggering a volume migration receive and supplying a crafted rsync or btrfs send stream that plants a symlink at a name such as rootfs or root.img; the flaw is an improper link resolution issue (CWE-59) in the receive path that does not confine link targets to the volume. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, though the independent assessment rates this a genuine high-priority vulnerability rather than a CVSS-inflated one given the authenticated, low-privilege path to root.
Path traversal in Canonical LXD's Btrfs storage driver allows an authenticated user with instance-creation privileges to escape the intended backup import target and delete or replace arbitrary files and directories on the host as root, by supplying a crafted subvolumes[].path value in backup/optimized_header.yaml during a btrfs 'optimized' backup import. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, 9.9) reflects high confidentiality, integrity and availability impact with a scope change because the traversed write lands outside the LXD daemon's own container boundary; exploitation requires valid low-privilege API credentials and a Btrfs-backed host, not anonymous access. No public exploit code has been identified at time of analysis, and the issue is not confirmed actively exploited (CISA KEV), but the low attack complexity and root-level file-system effect make it a genuine high-priority fix rather than a CVSS-inflated score.
Privilege escalation to remote code execution in Apache Karaf before 4.4.12 lets any authenticated shell session - including one holding only the viewer role - execute every jdbc:* and jms:* command, because the command guard (SecuredSessionFactoryImpl) treats commands with no matching ACL rule as permitted and the jdbc/jms ACL configuration files are never shipped. An attacker can use jdbc:ds-create to store a fully controlled JDBC URL into a pax-jdbc-config factory Configuration that is reactively turned into a live DataSource; drivers that act on URL parameters at connect time (for example H2 with INIT=RUNSCRIPT) then execute attacker code, bypassing the admin-role gate that protects shell:exec. No public exploit code identified at time of analysis, EPSS is low at 0.19% (8th percentile), and no CISA KEV listing applies; vendor-released patch: 4.4.12.
Authenticated path traversal in Apache Karaf before 4.4.12 allows a principal holding the shipped 'manager' role to write attacker-controlled content to arbitrary files writable by the Karaf process, because ConfigRepositoryImpl.update() and createFactoryConfiguration() build the target configuration filename from caller-supplied input without confining the result to ${karaf.etc}. Under Karaf's default command/JMX ACL (org.apache.karaf.command.acl.conf.cfg maps 'update = manager'), this lets a manager-role user overwrite files the same ACL reserves to 'admin' - such as etc/users.properties, etc/*.acl.*.cfg, and etc/org.apache.karaf.management.cfg - and thereby grant themselves the admin role or take over the container. The advisory does not indicate active exploitation, and no public exploit code has been identified at time of analysis; EPSS is 0.17% (6th percentile), indicating low predicted exploitation, while published scoring (CVSS 9.8, PR:N) is more severe than this assessment, which requires an authenticated manager-role principal (PR:L) on a deployment that exposes Karaf management and grants manager to non-admins.
Signature verification bypass in Authlib 1.7.2 and earlier allows unauthenticated remote attackers to have crafted JWS JSON Serialization payloads accepted as valid, because JsonWebSignature.deserialize_json() returns the payload without checking for a signature or requiring a cryptographic key. The flaw affects applications that use that method to process incoming tokens and then trust the returned payload for authentication, authorization, or integrity decisions; applications using only compact JWS or independently verifying signatures are not exposed. No public exploit code has been identified at time of analysis, and EPSS is low at 0.12% (2nd percentile), but the issue is remotely exploitable with no authentication or user interaction and is assessed as high severity.
Default or unchanged credentials in Logsign SIEM 6.4.101 through 6.4.116 allow remote, unauthenticated attackers to gain full control of an exposed instance simply by trying vendor-supplied or commonly used username and password pairs. The flaw is rated CVSS 3.1 9.8 Critical (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) because a successful login yields complete confidentiality, integrity and availability impact on a platform that aggregates security telemetry and often holds integration credentials for other systems. Exploitation requires network reachability to the Logsign SIEM authentication/management interface and that the deployment still uses default or unchanged common credentials; no prior authentication is needed. At the time of analysis there is no public exploit code or confirmed CISA KEV active exploitation, and no EPSS score was supplied, but the low attack complexity and the value of the target make internet-exposed instances a high-priority risk. The issue was reported by TR-CERT and is tracked against CWE-1392.
Denial of service in Ricoh SP 330DN, SP 221, SP C252SF, and Aficio SP 3500SF multifunction printers (firmware through 20260813) allows a network-reachable attacker with low-privilege credentials to hang the device by submitting a crafted multipart/form-data request to the embedded HTTP management interface. The flaw is an improper-resource-handling condition (CWE-404) in the multipart form-data parser that the researcher's PoC describes as an infinite loop, exhausting device resources with no confidentiality or integrity impact. Publicly available exploit code exists and a proof-of-concept script targeting the SP 330DN has been published on GitHub; the vendor did not respond to the disclosure, so no vendor-released patch is identified at time of analysis. This is a confirmed active-exploitability signal in the form of public tooling, but it is not listed in CISA KEV, and the practical exposure is largely limited to attackers on the same LAN or any environment where the printer's management interface is internet-reachable.
Authenticated PowerShell command injection in ManageEngine DDI Central (versions below 6201) allows a low-privileged user to achieve remote code execution by embedding malicious content in DNS SPF/TXT records that the product pushes to a managed Windows DNS server. The flaw is network-reachable and low-complexity (CVSS 3.1 base 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), requiring only a valid low-privilege account and an active Windows DNS integration; no user interaction is needed once the poisoned record is pushed. No public exploit code or confirmed active exploitation was identified at time of analysis, and no EPSS score was supplied in the source data.
Stored cross-site scripting in the SUSE Rancher UI allows unauthenticated remote attackers to inject malicious script through updates to public UI settings, which then executes in the browser of any user-including administrators-who later views the affected interface. Affected versions are SUSE Rancher 2.15 before 2.15.2, 2.14 before 2.14.6, 2.13 before 2.13.10, 2.12 before 2.12.14, and 2.11 before 2.11.18. Vendor CVSS 3.1 rates this 9.6, while our independent assessment lowers the availability impact to low; no public exploit identified at time of analysis, and exploitation requires network reachability to the Rancher management endpoint plus a victim loading the UI.
Denial of service in Barco ClickShare CX-20 Gen2 (firmware up to 02.26.00.0007) allows an authenticated, low-privilege attacker with network access to the device's management interface to disrupt or crash the unit by submitting a malformed 'wallpaper' argument to the /wallpaper upload endpoint. Publicly available exploit code exists, though no confirmed active exploitation (CISA KEV) has been reported. The impact is availability-only, with no data exposure or code execution, and the vendor was contacted but did not respond.
Path traversal in DbGate 7.3.1 and earlier allows unauthenticated remote attackers to read arbitrary files from the server via the 'runid' parameter in the Files Endpoint of packages/api/src/controllers/runners.js. Publicly available exploit code exists, and no vendor-released patch has been identified at time of analysis. Exposure is limited to deployments where the DbGate API/web server is reachable by the attacker, rather than local desktop-only usage.