Authenticated remote code execution in IBM TRIRIGA Application Platform 5.0.0 through 5.0.8 arises from improper validation of file paths inside archives the platform extracts, allowing an attacker with a valid account to write files to arbitrary locations and execute code under the privileges of the TRIRIGA service (CVSS 3.1: 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The attack is network-reachable with no user interaction and low complexity, but the PR:L vector gates it behind an existing authenticated session, confining realistic exploitation to insiders or attackers who have already obtained platform credentials. No public exploit identified at time of analysis, and IBM has published a vendor patch advisory covering the affected 5.0.0-5.0.8 range.
Authenticated back-office users of Thelia through 2.6.1 can chain a path traversal flaw in the translation editor with a PHP string-escaping failure to write and execute arbitrary PHP code on the server, achieving remote code execution with web-server privileges. The attack requires a back-office account holding UPDATE-level permission on the admin.configuration.language resource (CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, assessed 8.8), so it is not reachable by unauthenticated or low-privilege users despite the network attack vector; no public exploit code and no confirmed active exploitation were identified at time of analysis, and EPSS is low at 0.47% (39th percentile), making this a high-impact but moderate real-world priority.
Authenticated remote code execution in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows an attacker who already holds valid low-privilege credentials (CVSS PR:L, AV:N, UI:N) to run arbitrary operating system commands on the underlying host, resulting in high confidentiality, integrity, and availability impact (CVSS 8.8). The root cause is improper neutralization of special elements used in an OS command (CWE-94), meaning user-supplied input reaches a shell command without adequate sanitization. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (not in CISA KEV), but a vendor patch is available per IBM's advisory, so unpatched 5.4.0.0 deployments exposed to multi-tenant users or broadly provisioned accounts should be prioritized for upgrade.
Remote code execution in ManageIQ (and its downstream Red Hat CloudForms) is possible because the YamlLoadAliases module overrides YAML.safe_load so that in production a Psych::DisallowedClass error silently falls back to YAML.unsafe_load, deserializing arbitrary Ruby objects. An authenticated attacker holding dialog import privileges (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) can upload a crafted YAML dialog payload containing a disallowed class to trigger an unsafe deserialization path with full confidentiality, integrity, and availability impact. No public exploit code has been identified at time of analysis and there is no CISA KEV listing, but Red Hat CloudForms has reached End of Life and no errata will be issued, so CloudForms operators cannot patch and must depend on restricting the dialog import role.
Nginx UI installations before 2.4.1 expose two account-security endpoints, POST /api/otp_enroll and POST /api/finish_passkey_register, that let an attacker holding a stolen, valid JWT bind an attacker-controlled TOTP secret or register an attacker-controlled passkey against the victim's account, producing persistent access that survives a password change. The CVSS vector (AV:N/AC:L/PR:L/UI:N) confirms exploitation requires an authenticated session rather than being unauthenticated, and no public exploit code has been identified at time of analysis. The TOTP path only succeeds if the victim has not already enabled TOTP, because it relies on an existing-enrollment guard, whereas the passkey registration path has no equivalent guard and is exploitable regardless of prior enrollment.
Remote OS command execution in IBM DataStage on Cloud Pak for Data 5.4.0.0 allows an authenticated attacker holding only low-privileged credentials to run arbitrary operating system commands on the underlying DataStage host, with high impact to confidentiality, integrity, and availability (CVSS 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is an OS command injection (CWE-78) in which specially crafted input is passed to a system command without proper neutralization, so no user interaction is required and a single crafted request over the network is sufficient once valid access is obtained. Exploitation is gated by the need for existing credentials on the instance, and there is no public exploit code identified at time of analysis; IBM has published a fix via support node 7288649.
Persistent code execution on a penetration tester's workstation is achievable through a relative path traversal (CWE-22) in the Metasploit Framework post module post/apple_ios/gather/ios_image_gather, affecting versions prior to 6.5.5. A hostile or tampered iOS device can return a crafted directory-listing entry (for example ../../msfconsole.rc) that the module interpolates without sanitization into the local destination path handed to client.fs.file.download_file(), overwriting ~/.msf4/msfconsole.rc, which every msfconsole invocation automatically executes at startup; because the written resource file can load a second written Ruby plugin, this converts into an interactive shell as the operator (frequently root) at the next console launch. Exploitation is not remote-unauthenticated against a default service: it requires operator interaction (UI:R) to run the specific gather module against an attacker-controlled Meterpreter session, no workstation authentication (PR:N) is needed, and the assessed attack complexity is High because the hostile device, the specific module, and the resulting file write must all align; no public exploit code was identified at time of analysis, and the flaw is fixed in the 6.5.5 release.
Configuration validation bypass in Nginx UI (nginx-ui) prior to 2.4.1 lets an authenticated user with configuration-write privileges inject restricted Nginx directives by placing a benign directive first on a single line and appending a semicolon-separated restricted directive such as load_module, js_import, perl, or user root, because ValidateConfigDirectives only inspects the first token of each newline-split line. The flaw affects the REST, nginx_config_modify, site, and stream write paths and can escalate to arbitrary code execution in the Nginx worker context when a loadable Nginx module is already present on the host, a precondition that limits practical impact. No public exploit code was identified at the time of analysis, and the vendor released patch version 2.4.1.
Authenticated users of Nginx UI (0xJacky/Nginx-UI) prior to 2.4.1 can bypass the built-in nginx directive validation and write arbitrary nginx configuration through the MCP tool nginx_config_add, which reloads nginx with the injected directives. Where nginx is built with the njs or perl module (as in the official Docker image), an attacker - or an MCP-enabled AI agent steered by prompt injection - can achieve code execution on the nginx host with the privileges of the nginx worker process. The CVSS score of 8.8 reflects a network-reachable, low-complexity path requiring only authenticated MCP access (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), making this a credible, actionable priority rather than a paper-high CVSS; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing).
Unauthenticated username-change in ZITADEL's hosted Login V1 UI lets a remote attacker rename any active human account - including administrators - by supplying only the victim's login name, locking legitimate users out of the identity provider. The underlying defect is CWE-306 (missing authentication for a critical function): the change-username handler acts on the account bound to the login flow before any authentication factor is verified, so deployments running ZITADEL 3.0.0 through 4.17.x with Login V1 enabled are exposed, while instances on a newer login flow or already upgraded to 4.18.0+ are not. No public exploit identified at time of analysis and no CISA KEV listing applies; the assessed CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L describes a high-integrity, low-availability impact bounded to the Login V1 population, consistent with the VulnCheck-reported CVSS 4.0 score of 8.8.
Improper authentication in IBM Planning Analytics 2.0 and 2.1 allows an attacker who already holds valid low-privilege credentials to escalate to unauthorized administrative access over the network, with high impact to confidentiality, integrity, and availability (CVSS 3.1 base 8.8, CWE-288). Because the vector carries PR:L, the flaw is not reachable by a fully unauthenticated outsider: the attacker must first obtain ordinary authenticated access to the deployment, after which the alternate-path authentication weakness grants administrative control. No public exploit code has been identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV), but IBM has published a vendor patch, so the primary risk is unpatched, internet- or partner-reachable Planning Analytics installations where low-privilege accounts are widely distributed.
Unsafe deserialization in the UYAP Document Editor before version 5.4.20 allows an attacker to inject objects into the application through a crafted document, resulting in code execution with the privileges of the editor process (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-502). Exploitation is unauthenticated and network-reachable with low complexity, but requires the victim to open or process an attacker-supplied malicious document (UI:R), which is the principal limiting factor; no public exploit has been identified at time of analysis, and the product is deployed specifically within the Turkish judicial (UYAP) user base, narrowing the realistic target set. Successful exploitation yields high confidentiality, integrity, and availability impact within the affected user's scope.
Server-side request forgery in the SearxNG-backed search tools shipped with the praisonaiagents Python package before 1.6.62 lets prompt-injected content hijack the agent's outbound HTTP requests and read the responses back into the model's context, enabling internal service and API disclosure plus internal host/port enumeration. The vulnerable sink is the LLM-exposed searxng_url tool parameter, which is forwarded to requests.get() without any validation of scheme, host, port, or resolved address; search_web and searxng_search are part of the default agent tool profile, so any agent that ingests attacker-controlled web pages, files, or upstream tool output is in scope. The CVSS vector is AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:L/A:L (8.8) - no authentication is needed (PR:N), but exploitation depends on the agent actually processing malicious content and the model complying with the injected tool call (UI:R); confidential impact is high while integrity and availability impact are low. No public exploit identified at time of analysis; in cloud deployments the same primitive can reach the instance metadata endpoint (169.254.169.254) and potentially expose IAM credentials, though that requires the instance metadata service to be reachable from the agent's network position.
Path traversal in the OTRS SendSupportBundle functionality allows an authenticated administrator to delete files outside the intended directory, limited by the operating system permissions of the OTRS application process. The issue affects OTRS versions 7.0.X through 2026.X before 2026.7.X, as well as ((OTRS)) Community Edition 6.x and earlier; products based on Community Edition are likely affected. Despite a high CVSS score of 8.7, exploitation requires a valid administrative account and does not bypass OS file permissions, and no public exploit has been identified.
Server-side template injection in the back-office Email/Messages feature of Thelia 3.0.0 lets an authenticated user holding the 'Messages' permission submit unsandboxed Twig templates that the application compiles and executes as raw PHP, enabling arbitrary function calls, sensitive file reads, and potential filesystem writes that can compromise both the application and its underlying host. Exploitation requires valid back-office credentials plus the 'Messages' privilege (CVSS vector PR:L), so there is no anonymous or mass-exploitation path; EPSS is low at 0.19% (8th percentile) and no public exploit code or CISA KEV entry has been identified, though the flaw is remotely triggerable and rated 8.8 for its high confidentiality, integrity, and availability impact once the privilege prerequisite is met. The vendor has shipped a fix in thelia/twig-engine-module 1.0.9.
Command injection in the IBM Maximo Application Suite 'Location Service for Esri' component (versions 9.0, 9.1 and 9.2) allows a highly privileged attacker to execute arbitrary shell commands through a Kubernetes operator task, compromising confidentiality, integrity and availability beyond the component's own security boundary (CVSS 8.7). Exploitation is access-gated rather than trivial: the optional Esri location component must be deployed and enabled, and the attacker must already hold high privileges in the MAS environment (PR:H), but once those two conditions hold there is no user-interaction requirement and attack complexity is low, so injection is straightforward. No public exploit code and no confirmed active exploitation were identified at time of analysis.
Cross-origin requests to the obsidian-tc Model Context Protocol HTTP transport let any web page a victim visits read from and write to the entire Obsidian vault, because releases before 1.3.1 performed no Host or Origin header validation and ran with DNS-rebinding protection disabled. The issue affects deployments that run the Streamable HTTP transport bound to loopback under the documented auth.mode 'none' configuration, where inbound requests receive full wildcard vault scopes; the attacker needs remote, unauthenticated reach via the browser (PR:N) but must convince the victim to load an attacker-controlled page while the server is running (UI:R), yielding high confidentiality and integrity impact (CVSS 8.8, CWE-346). No public exploit was identified at time of analysis, and exploitation does not apply to server-to-server MCP clients (which send no Origin header), to deployments that configure any authentication mode other than 'none', or to version 1.3.1 and later, where host, origin, and DNS-rebinding validation are enabled by default.
Privilege escalation in IBM Db2 11.5.0 through 11.5.9 and 12.1.0 through 12.1.5 allows a local low-privileged attacker to gain elevated privileges on the Db2 host when the db2locssh feature is enabled. The vulnerability is not remotely reachable and requires an existing local account, making it a post-foothold escalation vector rather than a remote entry point. No public exploit code has been identified at the time of analysis, and IBM has released patches; this is a credible operational priority for environments with db2locssh enabled, but not an emergency.
Privilege escalation in IBM Db2 LUW (versions 11.5.0 through 11.5.9 and 12.1.0 through 12.1.5 on Linux, UNIX and Windows, including Db2 Connect Server) lets a locally authenticated low-privilege user elevate to higher privileges through improper privilege management, with high impact to confidentiality, integrity and availability and a scope change that can affect resources beyond the vulnerable component. Exploitation is constrained: the attacker must already hold a local foothold on the host and valid low-privilege credentials (CVSS vector AV:L/PR:L/UI:N), so this is not reachable by a remote unauthenticated adversary and realistically affects insiders or attackers who have breached another service on the same host. There is no public exploit identified at time of analysis and the issue is not in CISA KEV; a vendor patch is available, making this a credible, actionable priority for exposed Db2 LUW estate rather than an emergency.
Memory exhaustion denial of service in SGLang through 0.5.21 allows unauthenticated remote attackers to override the GLM-V video-processing resource budget by supplying attacker-controlled fps, max_frames, max_tokens_per_frame, and max_image_tokens values inside the video_url object of an inference request, causing glm4v.py to decode every frame of a high-resolution video at full size until worker memory is exhausted. Per CVSS PR:N in both the vendor-supplied CVSS 4.0 vector and the assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), the request path requires no authentication from the base vector, although in practice the endpoint is often fronted by a proxy or network boundary. Exploitation is limited to deployments serving a GLM-4V (GLM-V) multimodal model that accept video_url inputs; impact is availability only, with no code execution or data exposure, and no public exploit identified at time of analysis (no CISA KEV entry, no POC referenced).
Authenticated code injection in Craft CMS 4.x and 5.x allows a control panel user holding the performUpdates permission (or access to the Updates utility) to execute arbitrary code on the server by submitting a crafted 'updates' request to AppController::actionCacheUpdates. The endpoint forwards the raw request parameter into UpdatesModel without applying Component::cleanseConfig(), so an attacker can inject Yii behavior and event-handler configuration keys such as 'as' or 'on' - for example an AttributeTypecastBehavior gadget - and achieve remote code execution. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (High, 8.7 in the vendor's CVSS 4.0 scoring), and no public exploit code was identified at time of analysis; the practical barrier is the privileged-account requirement, which limits realistic exposure to malicious insiders, over-provisioned admin accounts, or environments where a control panel credential has already been compromised.
Remote code execution affects Craft CMS 5.10.2 up to but not including 5.10.14, where the Twig sandbox fails to block PHP callables passed to the 'has some' and 'has every' operators inside sandboxed system-message templates. Exploitation requires an authenticated control-panel account that has been granted the System Messages permission - a permission that can be delegated to non-admin users - after which the attacker can invoke two-argument functions such as passthru or system and execute code with the privileges of the web server user. Per current intelligence there is no public exploit identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV); the permission gate is the main limiter, so deployments that reserve System Messages for trusted administrators face materially lower practical risk than multi-user or agency installations that delegate that permission broadly.
Denial of service in SGLang through 0.5.21: unauthenticated remote attackers can exhaust server memory and CPU by submitting tiny, highly compressed FLAC files (typically pure digital silence) through the audio_url or audio_data inputs of the multimodal audio pipeline, which decodes them into enormous PCM buffers with no duration or sample-count ceiling. The issue is scored 8.7 under CVSS 4.0 (and AV:N/AC:L/PR:N/UI:N/A:H under CVSS 3.1) with availability impact only and no confidentiality or integrity impact, and no public exploit code was identified at time of analysis. Exposure is bounded: only deployments that actually serve an audio-capable multimodal model and accept attacker-supplied audio without authentication, request limits, or resource caps can be driven into memory exhaustion, making this a genuine but configuration-dependent availability risk.
Remote unauthenticated attackers can crash PHP worker processes in applications using Gumlet php-image-resize before 3.0.1 by submitting small, heavily compressed image files that expand into very large bitmaps when decoded by GD, exhausting the PHP memory limit and terminating the worker. Any upload or URL-fetch feature that hands untrusted images to the ImageResize constructor is exposed; the impact is availability-only, affecting individual PHP-FPM workers rather than enabling code execution or data disclosure. Severity is rated 8.7 (CVSS 4.0) and an independent assessment concurs on a high availability impact (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H); no public exploit code has been identified at time of analysis and the issue is not known to be actively exploited, but the attack is trivial to construct and the vendor characterizes this as a genuine availability risk rather than an emergency.
Memory exhaustion in modern-tar versions 0.3.5 through 0.8.5 lets remote, unauthenticated attackers crash or stall any process that unpacks an attacker-supplied tar archive, because a size field containing a non-octal byte (such as '/', '8', '9' or ':') is parsed by readOctal() into a negative entry size that the unpacker then buffers against indefinitely - the malicious archive may also be gzip-compressed. The impact is availability only (CVSS 4.0 8.7, assessed CVSS 3.1 8.1 with VC:N/VI:N/VA:H): no code execution or data disclosure is demonstrated, and the upstream 'Information Disclosure' tag is not supported by either vector. No public exploit code and no CISA KEV entry were identified at time of analysis; the practical limiting factor is exposure and configuration, since deployments that enable the library's strict parsing mode, or that only unpack trusted archives, throw on the malformed header instead of buffering and are not realistically exploitable.
Remote, unauthenticated denial of service in Zcash Foundation's Zebra full node: versions 6.4.0 through 6.4.1 abort when a peer sends a single version-6 transaction that carries a pre-NU6.3 consensus branch ID (Nu5/Nu6/Nu6.1/Nu6.2), because the malformed Orchard bundle cannot be re-serialized during UnminedTx size computation and the resulting error trips an `expect()` that terminates zebrad. The malicious `tx` message is accepted pre-handshake, so the attacker needs only network reachability to the node's P2P port, no credentials or completed peer negotiation, and the crash can be repeated after every restart for sustained unavailability; no public exploit code was identified at time of analysis, but the trigger is a trivial single message and the flaw is specific to Zebra 6.4.0-6.4.1 (patched nodes reject the transaction at parse time).
Unauthenticated memory exhaustion in SGLang through 0.5.21 lets remote attackers crash the HTTP/tokenizer worker and deny service by sending concurrent oversized multipart uploads to the /v1/audio/transcriptions endpoint, which reads each uploaded file fully into memory before validating its size. The flaw is CWE-770 (allocation of resources without limits or throttling) and is scored 8.7 under CVSS 4.0, with the independent assessment confirming CVSS 3.1 AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H. No public exploit identified at time of analysis, and the impact is availability-only: no confidentiality or integrity loss, and the service can be restarted once the flood stops.
Memory-exhaustion denial of service in SGLang (all versions through 0.5.21) allows remote, unauthenticated attackers to crash inference workers by submitting small, highly compressed images with enormous pixel dimensions to the image loader. The root cause is that NanoNemotronVLImageProcessor sets Pillow's Image.MAX_IMAGE_PIXELS to None, a process-wide global that disables decompression-bomb protection for the entire worker, including the generic image-loading path used by other models. Per the independent assessment this is a genuine but bounded availability risk: it only affects deployments that actually load NanoNemotronVLImageProcessor, and there is no public exploit identified at time of analysis. EPSS and CISA KEV data were not provided, so active exploitation is not confirmed.
Denial of service in SGLang through 0.5.21 lets remote attackers exhaust worker memory by submitting high-resolution video content to the OpenAI-compatible /v1/chat/completions endpoint on Qwen-VL multimodal deployments, with concurrent requests multiplying the allocation until the inference worker or host runs out of RAM. The root cause is preprocess_video in python/sglang/srt/multimodal/processors/qwen_vl.py (lines 267-306), which decodes every frame at full source resolution before the max_pixels downscaling limit is applied, so the documented memory cap does not constrain the expensive decode step. Severity is rated CVSS 4.0 8.7 (AV:N/AC:L/AT:N/PR:N/UI:N/VA:H, C/I integrity unaffected) and the assessed CVSS 3.1 equivalent is 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H); no public exploit identified at time of analysis, no CISA KEV listing, and real-world priority is moderate and tightly scoped because the practical limiting factor is exposure of the inference endpoint rather than exploitation difficulty.
Unauthenticated multipart uploads to the LogicalDOC Community Edition /upload endpoint (through version 9.3) let remote attackers write files into application temporary directories that are never cleaned up, exhausting server disk space and degrading or halting the document management service. The UploadServlet accepts file parts without a valid session and imposes no limit on the number of parts per request, so no credentials, user interaction, or non-default configuration are needed - only network reachability to the endpoint. Impact is confined to availability (integrity and confidentiality are unaffected, per the assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H vector), no public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV.
An incorrect authorization flaw in the WinBox authentication flow of MikroTik RouterOS lets a remote authenticated attacker who holds valid credentials for a low-privilege, WinBox-permitted account take over the authorization policy of a different, higher-privileged account such as admin. The EC-SRP stage-one challenge and proof are validated against the attacker's own account, but the separately supplied stage-two username determines which privilege policy gets installed, so the attacker ends up with a full administrative session without ever knowing the admin password, and can then use it to elevate their own account. Coverage across ENISA and CERT.LV reporting with a CVSS 4.0 score of 8.7 indicates a high-severity, network-reachable issue; no public exploit code has been identified at time of analysis. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, meaning exploitation requires one valid low-privilege WinBox-enabled credential and network reachability to the WinBox service.
Unauthenticated information disclosure in Grav CMS 2.0.22 through 2.1.6 lets attackers read sensitive Clockwork profiler records - including system and plugin configuration, secrets, request metadata, and database queries - when the profiler is active and the site sits behind a same-host HTTP proxy. The flaw is an authentication bypass: the profiler treats any request whose REMOTE_ADDR is a loopback address (e.g. 127.0.0.1) as an authorized local client, so requests forwarded through a co-located proxy inherit that trust. Exploitation is conditional rather than trivial - the profiler is a debug feature and must be enabled, and the attacker must be able to reach the application through the loopback-presenting proxy path; no public exploit code was identified at time of analysis, and this is not a CISA KEV entry. The impact is confidentiality-only (no integrity or availability effect) and is best characterized as a genuine but conditional disclosure flaw rather than a blanket high-severity emergency.
Authenticated remote code execution in LogicalDOC Community Edition through 9.3 allows any user with a valid account to execute OS commands with the privileges of the LogicalDOC process by injecting Velocity template expressions into the subject or message fields of DocumentService.sendAsEmail. The attacker can bypass the forbidRuntimeUsage denylist by invoking SystemTool exec methods or ClassTool, as the denylist only blocked java.lang.Runtime and not java.lang.ProcessBuilder. No public exploit code has been identified at time of analysis, but a vendor fix is available as commit 66c3a6b9b47f9f6c624047eea43b219851378f00 and the issue is tracked by VulnCheck.
Denial of service in N3.js before 2.11.1 lets unauthenticated remote attackers stall Node.js applications that parse untrusted Turtle or N3 by supplying long runs of digits that never terminate a valid numeric literal, driving the N3Lexer number regular expression into quadratic backtracking that blocks the event loop. The flaw (CWE-1333) is reachable with AV:N/AC:L/PR:N/UI:N and results only in availability loss (VC:N/VI:N/VA:H in the vendor CVSS 4.0 vector; CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H in independent assessment), with no confidentiality or integrity impact. It is not listed in CISA KEV and no public exploit identified at time of analysis, so real-world exposure is governed by whether the deployment actually feeds attacker-controlled RDF documents into N3.js parsing paths.
Information disclosure in Grav CMS before 2.1.7 lets unauthenticated remote attackers retrieve Git metadata from nested repositories - for example /user/.git/ - exposing git config, refs, and object files that can be used to reconstruct unpublished history or recover committed secrets. The flaw exists because the web-server configurations bundled with Grav for nginx, lighttpd, IIS, and Caddy 2 block dot-prefixed paths such as .git only at the document root, so repositories created below the root (a version-controlled user/ directory, or git-installed plugins and themes) remain web-readable. No authentication or user interaction is required; no public exploit code or confirmed active exploitation was identified at time of analysis, and real-world impact is gated by the deployment precondition that a web-reachable nested Git repository actually exists and contains private history or sensitive commits. The vendor advisory (GHSA-5vx9-x8f2-f55w) points to the 2.1.7 release as the fix.
Privilege escalation in Nginx UI lets any holder of an authenticated account take over the built-in administrator by changing the admin's password through POST /api/users/:id, which omits the RequireSecureSession step-up that the self-service password-change path enforces. Successful abuse silently invalidates the legitimate administrator's existing tokens, and the attacker can then authenticate as the administrator with full control over the Nginx configuration managed by the UI. All releases prior to 2.4.1 are affected; the vendor-released fix is version 2.4.1, and no public exploit code has been identified at time of analysis, though the assessed CVSS:3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects complete loss of confidentiality, integrity, and availability. The practical exposure is gated by the need for a pre-existing low-privilege account, so multi-user deployments are directly at risk while single-admin instances that never provision secondary users have no untrusted principal to abuse.
Authenticated attackers with a common operational role can exploit a server-side template injection in Frappe ERPNext before 15.119.1 and 16.x before 16.32.0 to read and write arbitrary database data, delete documents, send outbound requests from the server, and send mail from the site. The vulnerability arises because user-controlled message fields are not validated before template rendering, allowing expressions to execute in an unrestricted context (CWE-1336). With a CVSS 4.0 score of 8.7, no public exploit has been identified at time of analysis, but the low privilege requirement makes this a credible priority for organizations running unpatched versions.
Missing authorization in LogicalDOC Community Edition through 9.3 allows any authenticated low-privilege user to disclose, tamper with, or delete documents they are not permitted to access, by invoking SoapDocumentService operations such as copy, getExtractedText, deleteVersion, reindex, deleteLink, and restore over SOAP or the /services/rest/document REST interface. Because document identifiers are sequential, an attacker with ordinary credentials can simply enumerate IDs and reach other users' content with no administrative rights and no user interaction, yielding high confidentiality and integrity impact with limited availability impact (assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L; vendor-published score 8.7). No public exploit code or confirmed active exploitation was identified at time of analysis, and the main barrier to attack is the requirement for a valid account, so exposure is greatest where account creation is open or user segregation is weak.
SQL injection in Frappe ERPNext 15.x before 15.121.0 and 16.x before 16.34.0 lets any authenticated user, including an account with no assigned roles, inject crafted parameters into several endpoints that lack input validation, read other users' sensitive information, and escalate to a privileged account. Because only the lowest privilege level is needed (CVSS 4.0 PR:L; independently assessed at 8.7 under a 3.1 vector of AV:N/AC:L/PR:L/UI:N with High confidentiality, integrity and availability impact), deployments that permit self-registration or hand out broad low-privilege accounts face a nearly trivial authentication barrier, while tightly controlled instances still require a valid login. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV, but the vendor advisory is public, so unpatched, internet-reachable instances should be treated as high priority.
Privilege escalation in Frappe ERPNext lets any authenticated user - including one holding no operational role - create privileged records such as user accounts and role assignments, ultimately taking full control of the site. The flaw affects releases before 15.111.0 and 16.x before 16.22.0, and stems from a record-creation endpoint that derives the record type from the request and inserts it with permission checks disabled; the only prerequisite is a valid login (CVSS 4.0 vector PR:L, i.e. authenticated, no user interaction, no non-default configuration). Rated 8.7 with high confidentiality, integrity and availability impact across the vulnerable site, and no public exploit code has been identified at time of analysis.
Code injection in the IBM Maximo Application Suite Location Service for Esri component (versions 9.0, 9.1 and 9.2) allows an attacker who already holds high-privilege control over the Kubernetes operator's configuration input - specifically the container image reference consumed from an operator template - to inject a code path that the operator then acts on, resulting in a scope-changing compromise of workloads beyond the operator's own authority (CVSS 3.1 8.7, AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:N, CWE-94). The injected image reference can cause attacker-influenced containers to be deployed under the operator's service account, which is why the impact is rated high for confidentiality and integrity even though the attack is not reachable by an unauthenticated outsider against a default deployment. Exploitation is gated by PR:H - the adversary must be able to modify the Location Service for Esri operator's template or custom resource values - no user interaction is required, and there is no public exploit identified at time of analysis.
Stored cross-site scripting in Tuleap Enterprise Edition 17.0 through 17.5 allows an attacker holding a low-privileged authenticated account to persist arbitrary script into content that is later rendered in another user's browser, where it executes within that victim's authenticated session (CVSS 3.1 base 8.7, scope-changed). Exploitation is not unilateral: it requires a valid account with enough privilege to submit persistent content into a field shown to other users (PR:L) plus a victim who views the poisoned content (UI:R), so practical severity depends on how many users - and how privileged those users - can be induced to open the crafted page. No public exploit identified at time of analysis, and no EPSS or CISA KEV corroboration of active exploitation was supplied with the intelligence.
Stored cross-site scripting in Tuleap Enterprise Edition 17.0 through 17.5 allows an authenticated user with only low privileges to persist malicious script content into application fields, which then executes in the browser session of any other user who views the poisoned page. Because the payload is stored rather than reflected, a single injection can fire repeatedly against multiple victims, including higher-privileged users, and the CVSS scope change (S:C) reflects that the script runs with the privileges of the victim's origin rather than the attacker's account. Exploitation requires valid credentials (PR:L) and victim interaction (UI:R), and no public exploit code was identified at time of analysis; no EPSS score, CISA KEV entry, or active-exploitation reporting was provided in the available intelligence.
Stored cross-site scripting (XSS) in Tuleap Enterprise Edition 17.0 through 17.5 allows an authenticated attacker to inject malicious script into a persisted field, which then executes in the browser session of any user who views the affected content. The vulnerability requires a low-privileged account (PR:L) and user interaction (UI:R) from a victim, and can lead to high confidentiality and integrity impact. No public exploit identified at time of analysis.
Remote code execution in Adminer before 6.1.1 allows authenticated users with SQLite access to bypass ATTACH and VACUUM INTO restrictions by prefixing SQL statements with a UTF-8 byte-order mark. An attacker can then attach a database file at a PHP-served path and create a table named with PHP code, which executes as the web server user. No public exploit identified at time of analysis; exploitation requires valid credentials, SQLite usage, and a web-accessible writable PHP-executing path.
Improper verification in the Edgeless Systems Contrast Coordinator's peer-recovery path (versions 1.8.0 through 1.24.0) lets an authenticated actor who holds write access to the Coordinator's manifest history replay a superseded history head, because the recovering peer never confirms that the serving peer is on the same manifest generation. Successful replay can cause withdrawn workloads to receive trusted mesh certificates, and an attacker who additionally possesses the secret seed can disclose the Mesh CA key; the flaw is conditional rather than mass-exploitable, requiring PR:H privileges plus a specific transient/replayable state (AT:P), and no public exploit has been identified at time of analysis. Patched versions of Contrast (1.24.1 and later) address the missing generation check.
Buffer overflow in the Edimax BR-6208AC router (firmware 1.32) allows an attacker who can reach the device's HTTP management interface to corrupt memory via a crafted 'ifname' argument sent to the /goform/formWlSiteSurvey endpoint, with high impact to confidentiality, integrity, and availability. Exploitation requires at least low-privileged authenticated access to the web UI (CVSS 4.0 vector PR:L; independently assessed CVSS 3.1 base 8.6), meaning the endpoint must be reachable either from the LAN or from an internet-exposed admin panel using valid or default credentials; no user interaction is required once the attacker is authenticated. Publicly available exploit code exists (a PoC walkthrough is published on GitHub), but there is no evidence of confirmed active exploitation in the wild, and the vendor did not respond to disclosure - the product is end-of-life and no fix is expected.
Remote code execution in the Thelia e-commerce platform (all versions before 3.1.2 and 3.2.x before 3.2.1) allows an authenticated back-office user to upload a PHP payload that is written into the web-served public/cache/documents/ directory and executed as the web server user. The flaw exists because FileProcessorService validates the filename exactly as the client sent it, while FileManager::renameFile()/sanitizeFileName() later strips characters outside [a-zA-Z0-9-_.], so a name such as 'report.php ' survives validation but is stored as the executable 'report.php'. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) confirms exploitation requires a valid administrative account with access to the document-upload feature; no public exploit code has been identified at time of analysis, and the vendor has released fixed versions 3.1.2 and 3.2.1.
Privilege escalation in the Grav API plugin (grav-plugin-api) before 1.0.36 allows an account that already holds the api.users.write capability - a delegated user manager rather than a super-admin - to obtain full super-admin API access. The attacker edits account access maps or pending invitations so that a positive scalar value is stored on an 'admin' or 'api' parent grant; the plugin's inheriting permission resolver then treats that grant as satisfying its requireSuper checks, exposing super-only API endpoints. Exploitation is authenticated and requires the high-privilege api.users.write capability (CVSS vectors show PR:H, scope unchanged), so the flaw matters mainly where user-management rights have been delegated below super-admin; no public exploit code or confirmed active exploitation was identified at time of analysis.
Two-factor authentication bypass in the Grav Login plugin versions 2.7.0 through before 3.9.9 allows an authenticated remote attacker who already possesses a valid password to restore a remember-me cookie issued after the password step and obtain a fully authorized session without completing the second factor, yielding high confidentiality and integrity impact. This is a genuine elevated-priority issue for environments using the plugin with 2FA and remember-me enabled, though not a mass-exploitation emergency; no public exploit identified at time of analysis.