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.
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.
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.
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.
Authenticated low-privilege attackers can achieve remote code execution on ManageEngine DDI Central deployments before build 6201 by uploading arbitrary files through the High Availability failover configuration-sync endpoint, which writes attacker-controlled content to the filesystem and enables code execution. The flaw is network-reachable with low complexity and no user interaction, but requires valid credentials and that the HA feature be reachable; no public exploit code or active exploitation is currently confirmed. With a CVSS base score of 8.8, the issue carries high confidentiality, integrity, and availability impact for affected infrastructure-management instances.
Authenticated low-privilege attackers can invoke destructive PostgreSQL database operations in Zoho ManageEngine DDI Central by exploiting insufficient access control on the high-availability (HA) failover endpoint in all versions before 6201. With a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), the flaw is network-reachable, requires only low-privilege credentials and no user interaction, and carries full impact to confidentiality, integrity, and availability - an attacker who reaches the failover endpoint can act well beyond their intended permissions. The vendor has published a fix in version 6201, and no public exploit code has been identified at time of analysis; this CVE is not in CISA KEV, so there is no confirmation of active exploitation.
Authenticated command injection in Apache Karaf's instance-management service lets a principal who can reach the instance:* shell commands (instance:create, instance:start, instance:restart, instance:change-opts) or the equivalent InstancesMBean JMX operations execute arbitrary OS commands as the Karaf process user, because the caller-supplied javaOpts value is concatenated into a launch string that is then handed to /bin/sh or cscript. Affected deployments are Apache Karaf instances before 4.4.12, and exploitation requires an authenticated principal (CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) with the ability to supply javaOpts; the risk is amplified by a fail-open default in which unconfigured command scopes are not role-restricted. EPSS is low (0.40%, ~32nd percentile), CISA SSVC records no known exploitation, and no public exploit code was identified at time of analysis, so this is a high-priority but not an emergency issue.
PHP object injection in the ConvertPlus WordPress plugin (all versions through 3.6.3) allows any authenticated attacker at Subscriber level or above to reach the cp_display_preview_modal AJAX action, bypass its nonce guard simply by omitting the cp_admin_page_nonce parameter (the isset() check fails open and no capability check is performed), and inject a second attacker-controlled [smile_modal] shortcode via the style parameter that ultimately feeds attacker-supplied base64-decoded bytes into maybe_unserialize() with no allowed_classes restriction. The object-injection primitive is inert by itself - ConvertPlus ships no usable POP gadget chain - so real impact such as arbitrary file deletion, sensitive data disclosure, or code execution requires a separate installed plugin or theme that provides a compatible chain. No public exploit code or confirmed active exploitation was identified at time of analysis, and the assessed vector (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8) reflects the low-privilege login requirement and the strong third-party gadget-chain dependency rather than automatic compromise.
Authorization bypass in Apache Karaf before 4.4.12 allows an authenticated JMX client holding any role - including the least-privileged 'viewer' - to evade RBAC and achieve remote code execution inside the Karaf JVM. Karaf's MBeanServer guard never checks the lifecycle operations createMBean, registerMBean and unregisterMBean, so a caller can instantiate and register the standard javax.management.loading.MLet class and then invoke its getMBeansFromURL operation, which the shipped default 'get* = viewer' ACL wildcard inadvertently authorizes, causing attacker-hosted classes to be fetched and loaded as new MBeans. Exploitation requires network reachability to the default-enabled remote JMX RMI connector on ports 1099/44444, a valid JMX credential of any role, and outbound network access to the attacker's .mlet host; no public exploit code and no active exploitation were identified at time of analysis, and the issue is rated important by the vendor while the independent assessment places it at high impact across confidentiality, integrity and availability.
Privilege escalation in SUSE Rancher Fleet (0.14.x before 0.14.11, 0.15.x before 0.15.7, and 0.16.x before 0.16.2) lets a low-privileged tenant - an authenticated user able to push a Fleet Bundle or GitRepo - have resources written to a shared downstream cluster under the Fleet agent's own cluster-admin credentials rather than the ServiceAccount pinned to the deployment, allowing that tenant to overwrite configuration owned by other tenants. Exploitation is gated by topology: it only matters in multi-tenant Fleet deployments where privileged and untrusted teams share the same downstream cluster, since single-tenant or per-tenant-isolated clusters have no crossed trust boundary. Rated 8.8 by the vendor (the independent assessment scores it higher, 9.9, because the trust boundary crossing changes scope); no confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis.
OS command injection in aaPanel BaoTa through 11.8.0 lets an authenticated panel operator execute arbitrary shell commands on the underlying host by supplying a crafted Password value to the archive-extraction routine. The defect sits in the function panelTask.bt_task._unzip within /www/server/panel/class/panelTask.py, and because the panel normally runs as root a successful injection yields full server compromise; a user-interaction step is required to invoke the unzip workflow. Publicly available exploit code exists (disclosed via a public gist referenced by VulDB), the vendor was contacted early but did not respond, and no vendor-released patch has been identified at time of analysis - this is the third near-identical command-injection flaw in the same release line alongside CVE-2026-101007 and CVE-2026-101008.
An unauthenticated remote attacker can lock up an Angular server-side rendering process by submitting HTML that contains an unterminated DOCTYPE declaration with trailing whitespace (for example `<!DOCTYPE html `), which drives the bundled domino HTML parser into an infinite synchronous loop that pins a CPU core at 100% and stalls the Node.js event loop, silently dropping all concurrent and subsequent requests. Only SSR deployments that run @angular/platform-server and feed attacker-controlled markup into server-side DOM parsing - via `[innerHTML]`, interpolation into rendered HTML, `insertAdjacentHTML`, `outerHTML`, or server-side sanitization - are reachable; the vulnerable version ranges are <=19.2.25, 20.0.0 through 20.3.30, 21.0.0 through 21.2.22, and 22.0.0 through 22.1.5. The trigger payload is trivial to construct, but no public exploit code has been observed circulating and the issue is not listed in CISA KEV, so the practical risk is a function of whether the application actually routes untrusted HTML through domino on the server.
OS command injection in SUSE NeuVector 5.4 (before 5.4.11), 5.5 (before 5.5.4), and 5.6 (before 5.6.2) allows an attacker who already satisfies one of two prerequisites - an authenticated NeuVector user holding the namespaced Runtime Policies (write) permission, or possession of NeuVector's internal gRPC certificate key pair - to inject operating-system commands that execute inside the privileged enforcer container, resulting in complete compromise of the underlying worker node. The flaw is rated 8.8 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning remote reachability, low attack complexity, authenticated low privileges, and no user interaction, with total confidentiality, integrity, and availability impact once the prerequisite is met. Ordinary read-only users and unauthenticated network clients cannot trigger it, but any deployment that grants Runtime Policies write access broadly or leaks the internal gRPC key pair is at high risk; no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, though weaponization would be straightforward given the trivially reachable command sink.
Authenticated remote code execution in FreePBX (versions prior to 16.0.10 and 17.0.5) lets an attacker who possesses a valid, known username abuse the sound-language upload and conversion workflow to write arbitrary files, including malicious PHP, into the web server's document root. The root cause is a path-traversal weakness (CWE-22) in the conversion step where path sanitization is insufficient, and successful exploitation gives full confidentiality, integrity and availability impact on the PBX host (vendor CVSS v4.0 8.7; independent assessment CVSS v3.1 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, so authentication - not user interaction - is the gate). No CISA KEV entry and no public exploit code were identified at time of analysis, meaning this is a high-severity, patch-now issue for PBX administrators rather than a mass-exploitation emergency; practical risk concentrates where FreePBX administrative panels are internet-facing or protected by weak or default operator credentials, and is reduced where the panel is network-segmented.
Code injection in Innotim Logsign SIEM versions 6.4.101 through 6.4.117 exposes network-reachable deployments to full compromise of confidentiality, integrity, and availability, as reflected by the CVSS 3.1 score of 8.8 and the CVE's CWE-94 classification. According to the CVSS vector (AV:N/AC:L/PR:L/UI:N), exploitation requires a valid low-privilege authenticated account on the SIEM instance, needs no user interaction, and can be carried out with low complexity - an anonymous attacker cannot trigger it without first obtaining credentials, and the risk is confined to the stated version window. No public exploit code or confirmed active exploitation was identified at time of analysis, and the specific vulnerable feature or endpoint is not disclosed in the available advisory data.
Authenticated SQL injection in Iron Mountain enVision builds prior to 260655 allows a network-based attacker holding a low-privilege account to inject arbitrary SQL through an improperly neutralized input parameter. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) reflects low-complexity exploitation with no user interaction and high impact across confidentiality, integrity, and availability, meaning an authenticated user could read, modify, or destroy database contents. No public exploit code has been identified at time of analysis and there is no CISA KEV listing, but the vendor reports a patch is available; discovery is credited to TR-CERT (Turkish national CERT).
Authenticated abuse of the document upload function in eBA Plus Document and Workflow Management System (versions 6.7.141 through 10.0.10) lets a low-privilege user place a Web Shell on the server and, if the uploaded file can be reached through a web-accessible path, run code with the privileges of the web application. The defect is CWE-434 (unrestricted upload of a file with a dangerous type) and carries a CVSS of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so valid credentials or a self-registration path are required rather than unauthenticated access, and installations already on 10.0.11 or later are outside the affected range. No public exploit has been identified at time of analysis; TR-CERT (Turkish national CERT) is the reporting and reference source. This is a genuine high-priority issue for organizations running the affected product.
Unauthenticated stack-based buffer overflow in Buffalo WSR-300HP routers and WEX-G300 Wi-Fi extenders allows network-adjacent attackers to crash devices via crafted HTTP requests, causing denial-of-service. Exploitation requires network access to the HTTP management interface, typically only reachable from the local network unless remote administration is exposed to the WAN. No public exploit code or confirmed active exploitation (CISA KEV) has been identified, and the issue is assessed as genuine but low-priority due to reachability constraints.
Missing authorization in WarehousePG (WHPG) 7.x before 7.6.0-WHPG lets any authenticated database role - with no superuser rights, no GRANT, and no special role membership - call the built-in server-side file functions pg_file_write, pg_file_rename, pg_file_unlink and pg_logdir_ls, because the REVOKE that contrib/adminpack applies to the equivalent functions was never carried over to WHPG core when their catalog entries were repointed to the ungated adminpack-derived _v1_1 implementations during the merge onto a PostgreSQL 12 base. An attacker holding ordinary database credentials can therefore create, append to, overwrite, rename and delete files under the data and log directories and enumerate log file names, and by appending directives such as shared_preload_libraries or archive_command to postgresql.auto.conf can achieve arbitrary code execution as the postgres operating system user on the next server restart or configuration reload. WarehousePG 6.x is not affected because its equivalent functions enforce an internal superuser check, and no public exploit code has been identified at time of analysis (no CISA KEV entry).
Account takeover of the InvoicePlane primary administrator (user_id=1) is possible for any authenticated secondary administrator (user_type=1, user_id != 1) on version 1.7.2 prior to commit 8616fa4. The attacker uses Users::form(), which performs no object-level authorization check on the primary admin's record, to overwrite the primary administrator's user_email value (it is not listed in PROTECTED_FIELDS), then drives the instance's public, logged-out password-recovery flow that resolves accounts by user_email to obtain the reset token and seize control of user_id=1. This is an alternate path around the earlier fix in PR #1638, which protected only Users::change_password(); no public exploit code was identified at time of analysis and there is no CISA KEV entry, but the vendor has published a GitHub Security Advisory (GHSA-77hm-22wp-96wp) and a patch commit.
Authenticated command injection in FreePBX prior to 17.0.9 allows a user who is authorized to access the GraphQL API module interface to execute arbitrary shell commands on the PBX host, running as the web/PBX service account (typically 'asterisk'). The flaw sits in the PBX API module's documentation generator, which accepts a caller-supplied 'host' parameter and interpolates it into a shell command; the code validates the generated OAuth access token before execution but never validates or escapes the host value. Exploitation requires a pre-existing, privileged account with API-module authorization (CVSS:4.0 PR:H, our assessment CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), which materially limits exposure; no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor-released fix is version 17.0.9.
Circuit soundness failure in Payy (polybase/payy) prior to 1.3.0 lets an authorized rollup prover smuggle an extra burn message into the public messages[1000] array accepted by RollupV1.verifyRollup(), causing the rollup contract to transfer USDC from the contract to an attacker-controlled recipient. The attacker must be a registered prover with the ability to construct a valid agg_final proof for an already-approved rollup block and to manipulate the unconstrained tail of the public input array, so the assessed vector is authenticated (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N, integrity-only impact with no confidentiality or availability loss). Exploitability today is further limited because verifyRollup() is restricted to the existing allowlisted prover, but the flaw becomes effectively unauthenticated under the permissionless prover model in the Payy whitepaper (Section 3.3.2 stake-to-join and Section 3.3.1 fallback submission by other nodes). No public exploit code had been identified at time of analysis, and the vendor-released patch is version 1.3.0.
Authenticated command injection in the FreePBX User Control Panel (UCP) allows any account with UCP access - including low-privilege users who are frequently granted UCP but not Administrator Control Panel (ACP) rights - to run arbitrary commands on the PBX host as the web-server user (typically asterisk) via crafted HTTP requests. The flaw affects FreePBX versions prior to 16.0.39 and 17.0.7 and stems from insufficient sanitization of UCP URL parameters, which permits command chaining into host binaries; the vendor rates it CVSS 8.6 (CVSS:4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H) and the independent assessment concurs with high confidentiality and integrity impact over the network with low privileges required. No public exploit identified at time of analysis, and successful exploitation requires a valid UCP session plus network reachability to the PBX web interface, but no victim interaction.
Authenticated users holding backup or restore privileges on affected FreePBX deployments can achieve remote code execution through the backup Module on versions prior to 16.0.72 and 17.0.7. Improper path sanitization during backup restore lets a crafted archive place attacker-controlled PHP files directly into the web root, where the FreePBX web server will execute them, giving the attacker full control of the host and, by extension, the underlying Asterisk telephony platform (CVSS:4.0 8.6; independent assessment scores CVSS:3.1 8.8, AV:N/AC:L/PR:L/UI:N with high confidentiality and integrity impact). Exploitation is not pre-authentication: it requires a valid account with sufficient access permissions and/or write access to backup files plus network reachability of the FreePBX administration interface, and no public exploit code has been identified at time of analysis. This is a high-priority issue for internet-exposed or broadly permissioned FreePBX instances rather than a drop-everything emergency, since the primary attack surface is a privileged administrative workflow.
Authenticated remote code execution in the FreePBX Superfecta module (FreePBX prior to 16.0.40 and 17.0.7) allows a user holding valid credentials with a known username to make the module's AJAX handler dynamically include attacker-influenced PHP files from its sources/ directory, executing arbitrary PHP with the privileges of the web server user. Exploitation is remote and low-complexity from the attacker's side (CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:N, score 8.6), but our assessment notes the inclusion flaw alone is not sufficient: per the GitHub advisory (GHSA-j53p-5m8r-j3p6) the attacker must chain it with arbitrary directory creation via the backup module and a path-revealing file upload via the soundlang module, so the Superfecta, backup, and soundlang modules must all be present and a valid login is mandatory (CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H). No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis; vendor-released patches are available in versions 16.0.40 and 17.0.7, making this a high-priority fix rather than an internet-facing emergency, particularly for systems with the affected modules exposed to untrusted users.
Loading a malicious model into Unsloth Zoo 2025.9.9 through 2026.8.13 (as shipped in Unsloth 2025.9.9 through 2026.8.19) lets that model's config.json run arbitrary Python in the loading user's process, because a nested model_type value containing a newline escapes into an exec()-generated import statement. Exploitation requires the victim to load an attacker-controlled model for training or inference - a user-interaction gate, but no authentication on the attacker side (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H; vendor score 8.6). No public exploit code has been identified at time of analysis, and the practical exposure is concentrated in pipelines that automatically ingest third-party or user-supplied models from public hubs rather than those loading only vetted first-party checkpoints.
Authenticated command injection in BUFFALO WSR-300HP wireless routers and WEX-G300 range extenders lets a user who already holds administrative access to the device's web management interface execute arbitrary operating system commands by submitting a crafted HTTP request to a web form field. Successful exploitation yields full compromise of the device (confidentiality, integrity and availability all rated High), but the attack is gated behind valid admin credentials or an active admin session, which is the dominant risk-limiting factor, and the affected models are primarily Japanese consumer/SOHO devices. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; the vendor CVSS 4.0 score of 8.6 reflects impact severity once the prerequisite administrative access is met.
OS command injection in the WatchGuard AP diagnostic CLI allows an authenticated administrator to execute arbitrary operating system commands on the affected access point by supplying crafted input to a diagnostic parameter. The vulnerability carries a CVSS v4.0 base score of 8.6 (CVSS:4.0/AV:N/AC:L/AT:N/PR:H/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N) and is independently assessed as CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H; exploitation requires valid administrator credentials for the AP's CLI (PR:H), but once authenticated no user interaction and only low attack complexity are needed, yielding high confidentiality, integrity, and availability impact on the device itself. There is no confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis, so realistic risk is concentrated where the AP management/CLI is network-reachable and administrative credentials are weak, reused, or exposed.
Server-side request forgery and local file inclusion in Regular Labs Modules Anywhere for Joomla (Pro versions 1.5.0 through 9.0.5) allow an attacker with content-authoring privileges to override module parameters and cause the server to open attacker-influenced URLs or local files. The parameter-override feature is enabled by default and applies attributes without verifying who authored the content containing the module tag; Joomla's core Feed module with its rssurl parameter is a confirmed vector. The vendor rates this 8.5 under CVSS 4.0, but the independent assessment (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N) indicates high technical impact with moderate real-world priority because authentication is required and exposure depends on the selected module; no public exploit was identified at time of analysis.
Command injection in the aaPanel (BaoTa) server management panel through version 11.8.0 lets an authenticated high-privilege panel user execute arbitrary operating-system commands by manipulating the split_file_path argument handled by merge_split_file in /www/server/panel/class/files.py. The flaw is network-reachable and requires no user interaction, but it demands an existing administrator-level session (PR:H), so realistic risk is concentrated on panels with untrusted account holders, exposed management interfaces protected by weak or default credentials, or environments where admin credentials have already been stolen. Publicly available exploit code exists, exploitation evidence is rated E:P, and the vendor was contacted early but did not respond, so no fix is currently available; this is a genuine but conditional risk rather than a pre-auth emergency.