Authenticated command injection in IBM Guardium Data Protection 12.2 allows a user who can reach the GIM (Guardium Installation Manager) bundle import functionality to supply a crafted bundle whose contents cause attacker-controlled arguments to be passed to the underlying tar command, resulting in arbitrary command execution with elevated privileges on the Central Manager. The flaw is network-reachable and requires only low-privileged authentication (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) with no victim user interaction, so any account able to trigger a bundle import should be considered capable of full compromise of the Central Manager. No public exploit code or confirmed active exploitation was identified at time of analysis; the vendor has published a fix advisory.
Authenticated administrators of ClipBucket v5 who hold the manage_template_access permission can abuse a path traversal in the admin template editor (template_editor.php) to write attacker-controlled PHP files outside the intended styles/layout directory and have them executed as the web server user, yielding remote code execution on all versions before 5.5.3-#197. Publicly available exploit code exists (a HackMD writeup linked from the CVE record), and the vendor has released a fix in commit f31de49b and release tag 5.5.3-#197; the bug is access-gated by the administrator privilege and permission requirement (CVSS 4.0 base 8.6, PR:H), and there is no confirmed active exploitation in CISA KEV. This is a genuine but access-gated risk that primarily matters where multiple admin accounts exist or admin credentials are weak or reused.
PHP code execution on Netgate pfSense Plus and pfSense CE firewalls can be achieved by an authenticated, highly privileged webGUI user who can modify Dashboard widget settings and plant a crafted .widget.php file on the filesystem, then set a widget sequence value containing path traversal so Dashboard index.php include()s and executes that file. The vendor rates this High (CVSS 8.5), while the independent assessment keeps AV:N/AC:H but raises the privilege requirement to PR:H, reflecting that the attacker already needs substantial Dashboard and file-write access; it is not remotely exploitable without authentication. No public exploit or KEV-listed active exploitation was identified in the provided data, and Netgate has released fixed versions.
Incorrect authorization in phpIPAM's REST API (api/controllers/User.php) allows an attacker with API access to retrieve privileged user records by supplying the special identifiers id='admins' or id='all', bypassing intended access controls. Affected versions are those prior to 1.8.3, which includes a security fix for insecure direct object references. While the CVE lists a CVSS score of 8.6 (AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:N/A:N), the independent assessment indicates the flaw more realistically requires a valid API token (PR:L) and has no scope change (S:U); no public exploit code has been identified at time of analysis.
Authenticated privilege escalation in X-SpringBoot through 6.0 lets any account with delegated user-management permissions reset passwords, rebind roles, or delete users - including the super administrator - through POST /sys/user/update and POST /sys/user/delete because those endpoints perform no object-level ownership verification. Publicly available exploit code exists, in the form of the referenced Python BOLA proof-of-concept, but no CISA KEV status is provided and the risk is tempered by the PR:H requirement that the attacker already be a sub-administrator rather than an unauthenticated remote user. The impact is full compromise of user accounts on affected instances that delegate user-management privileges.
Command injection in Root Browser Classic 3.3.0 (Android, package com.jrummyapps.rootbrowser.classic) lets an attacker execute arbitrary shell commands with the app's privileges by supplying a SQLite database whose filename is seeded with shell metacharacters; the app passes that path to an operating-system shell without separating the filename from the command (CWE-78). Exploitation is local rather than remote: the crafted file must first reach the device (download, sideload, shared storage or another app) and the victim must then open it inside the app, so the flaw is gated by passive user interaction and confined to users of this root-capable file manager. No public exploit code was identified at time of analysis, and while exploitation yields high confidentiality, integrity and availability impact, the 8.5 CVSS v4.0 base score overstates the practical exposure because the realistic attack surface is narrow.
OS command injection in the PowerShell and Cmd wrapper classes of the CliInvoke.Specializations .NET library (and its predecessor package AlastairLundy.CliInvoke.Specializations) lets a double quote embedded in caller-controlled target paths or arguments break OS-level quoting of the single ProcessStartInfo.Arguments string, causing pwsh -Command or cmd /c to execute an additional command with the host process's privileges. Affected builds are CliInvoke.Specializations 2.2.0 through 2.8.4, 2.9.0 through 2.9.3, 2.10.0 through 2.10.4, and 3.0.0-alpha.1 through alpha.4 plus 3.0.0-alpha.8 through alpha.10, as well as AlastairLundy.CliInvoke.Specializations 1.0.0-rc.1 through 1.6.1.1; an application is only reachable if it consumes one of these vulnerable versions, uses the specialized shell wrappers rather than direct process invocation, and routes attacker-influenced data into the target or arguments. Rated CVSS 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) by reporter GitHub_M; no public exploit identified at time of analysis and the issue is not listed in CISA KEV.
Argument injection in the CliInvoke .NET process-wrapping library (and its former identity, AlastairLundy.CliInvoke) allows a double quote in a caller-supplied target or argument to break out of the operating-system-level quoted region and add unintended elements to a runner's argument vector, potentially escalating to arbitrary command execution when a shell runner is used. Affected versions span CliInvoke 2.0.0-2.8.4, 2.9.0-2.9.3, 2.10.0-2.10.4 and 3.0.0-alpha.1-3.0.0-beta.1, plus AlastairLundy.CliInvoke 2.0.0-alpha.1-2.0.0; the flaw is reachable only when a consuming .NET application routes attacker-influenced data through RunnerProcessFactory (2.x) or RunnerConfigurationFactory (3.x) instead of building a ProcessConfiguration with an explicit ArgumentList. Scored CVSS 3.1 8.4 (High) with vector AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, it carries no public exploit identified at time of analysis and is not in CISA KEV.
An authenticated guest with an active booking could unlock rooms other than their own in Akia's keyless entry cloud service by tampering with the client-supplied room or door identifier, because the unlock action was not authorized server-side against that guest's booking-resulting in unauthorized physical access to guest rooms at the affected property. The independent assessment rates this as CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N and notes the attack is remote but the impact is local to a single property. Akia reportedly remediated the service server-side as of September 19, 2026; no public exploit code or CISA KEV confirmation was identified at time of analysis.
Stored cross-site scripting in ITFlow's inbound email-to-ticket parser (cron/ticket_email_parser.php) lets a remote, unauthenticated sender deliver a ticket email carrying a malicious SVG attachment that executes script in the browser of any technician or admin who opens it, running with that staff user's privileges against the ITFlow origin (scope-changed, C:H/I:H). Every ITFlow release before 26.08 is affected, but exposure requires the deployment to actually run the email-ingestion pipeline and to accept inbound SMTP from arbitrary external senders; the payload does not fire on ingestion and needs a staff user to open the attachment (UI:R), which is reflected in the AC:H/UI:R vector. No public exploit code and no confirmed active exploitation were identified at time of analysis, and remediation is simple: the vendor-released fix in ITFlow 26.08 removes svg from the attachment allowlist. Given the CVSS 8.0 base score and the privileged session the script inherits, this is a genuine, moderately high-priority issue for exposed instances rather than an emergency.
The AetherBrowser API server shipped with SCBE-AETHERMOORE versions 4.0.2 through 4.2.0 exposes the POST /api/ops/check-email endpoint with no authentication check whatsoever, letting any remote, unauthenticated attacker invoke the email_reader.py subprocess, which logs into configured ProtonMail or Gmail accounts over IMAP and returns email metadata (sender, subject, and body snippets) in the JSON response. The server listens on 0.0.0.0:8100 by default and sets CORS allow_origins=["*"], so the endpoint is reachable from any network host and callable from any browser origin, though meaningful mailbox disclosure requires that IMAP credentials have actually been configured for the reader. Version 4.2.1 resolves the missing authentication (CWE-306); no public exploit code has been identified at time of analysis.
Local privilege escalation in GNU libextractor before 1.16 allows a low-privileged local attacker to execute arbitrary code with elevated privileges by pointing the LIBEXTRACTOR_PREFIX environment variable at a directory containing a malicious plugin, which the library loads from that untrusted search path without privilege checks. Exploitation requires a setuid or setgid consumer of libextractor to be installed and invocable on the host, so the issue is conditionally gated rather than a remote-facing emergency. Publicly available exploit code exists (a PoC repository is referenced), and the vendor has released a fix; no CISA KEV entry confirms active exploitation at time of analysis.
SQL injection in GLPI's history/logs tab allows an authenticated attacker who holds the READ right on logs to inject attacker-controlled values into a database query via crafted affected_fields filter parameters in the history-tab URL. The flaw affects GLPI releases from 9.4.0 up to but not including 10.0.26 and 11.0.8, and exploitation is gated by the READ-on-logs privilege, which is not held by ordinary or self-service users by default. No public exploit code or confirmed active exploitation has been identified at time of analysis; the vendor has released fixes in 11.0.8 and 10.0.26, and the issue is well-confirmed by the vendor advisory and two upstream fix commits.
Authenticated command injection in the D-Link DAP-2610 wireless access point (firmware up to 2.06B08r099) allows a user with valid low-privilege credentials on the web management interface to execute arbitrary system commands by supplying crafted parameters to the /index.xgi endpoint, giving full control of the device (CVSS 3.1 base score 8.8, C:H/I:H/A:H). The issue is network-reachable with low attack complexity and no user interaction, but authentication is required per the CVSS vector (PR:L), and CISA's SSVC assessment marks it as not automatable, so mass exploitation is unlikely. Publicly available exploit code exists; CISA KEV does not list this CVE, so active exploitation has not been confirmed at time of analysis.
Authenticated path traversal in IBM Guardium Data Protection 12.2 allows a remote low-privilege user with a valid management-interface session to read sensitive information, delete arbitrary files, or execute arbitrary code. The flaw is a CWE-22 directory-restriction bypass; SSVC rates exploitation as non-automatable, suggesting targeted rather than mass-scanning abuse, and no public exploit was identified at time of analysis (EPSS 0.54%). Patch available per vendor advisory.
Heap out-of-bounds write in the Linux kernel CIFS/SMB client (fs/smb/client) can corrupt slab memory when an ACL rewrite expands owner/group SIDs beyond the buffer that was sized from the on-disk DACL length. It is only reachable on systems that mount an SMB/CIFS share with the non-default cifsacl or modefromsid options and then trigger a local ACL-modifying operation such as chown or chmod, so the realistic outcome is kernel memory corruption or a crash rather than a remote attack; the source CVSS vector (8.8, AV:N/AC:L/PR:N/UI:R) is inconsistent with this local, mount-option-gated path. No confirmed active exploitation (no CISA KEV) and no public exploit code have been identified, and vendor patches are available with fixed builds including 6.18.53, 6.12.111, 7.2.7 and 7.3-rc3.
A use-after-free race condition in QEMU's 9pfs (virtfs) passthrough subsystem allows a malicious guest user to escape the shared directory boundary and read or write arbitrary files on the host, potentially achieving code execution as the QEMU process user (VM escape). Only hosts that have enabled 9pfs/virtfs host-directory sharing are exposed, since this is not a default configuration; the attacker must be a local guest user able to issue 9p protocol requests and must win a race between QEMU's main thread and a 9pfs worker thread with concurrent Tlcreate and Twalk requests. No public exploit code or active exploitation telemetry was identified at time of analysis, but the flaw is rated high severity (CVSS 8.8, scope-changed, C:H/I:H/A:H) and affects QEMU packages shipped in Red Hat Enterprise Linux 6 through 10, Red Hat OpenShift Container Platform 4, and related Red Hat products.
Remote code execution is achievable on self-hosted deployments of golang.org/x/playground by chaining two independent weaknesses: a crafted txtar archive that escapes the intended execution context and forces arbitrary writes into the playground host's trusted filesystem, plus a malicious go env configuration file that one of the three go vet invocation paths reads from the host's $HOME because that path fails to properly restrict its execution environment. Neither primitive is sufficient on its own - the attacker must combine the filesystem write with the poisoned environment file to reach code execution on the host, and the reachable surface is bounded to one specific vulnerable go vet invocation path out of three. The public go.dev/play service is explicitly NOT affected, so exposure is limited to independent forks and self-hosted deployments running golang.org/x/playground versions before 0.0.0-20260924211604-6d73cff14c17; no public exploit code or confirmed active exploitation was identified at time of analysis (CISA SSVC exploitation: none), and the vendor has released a patch.
Authenticated path traversal in the websocket/long-polling session handling of Zammad 7.0.2 and 7.1.0 allows a low-privilege logged-in user to delete arbitrary files and directories on the server with a single crafted request. The client-supplied session (client) identifier is insufficiently validated before being interpolated into internal filesystem paths, so traversal sequences escape the session storage directory - but only on instances using the default file-based session store, since Redis-backed deployments are not affected. Confirmed impact is integrity and availability loss (arbitrary deletion, no read/exfiltration per the assessed vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H); there is no confirmed active exploitation (CISA SSVC exploitation: none) and no public exploit identified at time of analysis, though the flaw is fully automatable. Note that the published CVSS 4.0 score of 8.8 carries PR:N, which overstates ease of access - the independent assessment confirms authentication is mandatory.
A use-after-free race condition in the Linux kernel's ksmbd in-kernel SMB3 server can crash the kernel (denial of service) when a session is torn down while multiple channels are bound to a session and deferred byte-range locks or pending CANCELs remain counted as running requests. Affected systems must have ksmbd enabled (CONFIG_SMB_SERVER) and exporting at least one SMB3 share, and an authenticated remote attacker (PR:L) must negotiate SMB3 multichannel to race a LOGOFF, synchronous CANCEL, or abrupt connection teardown against still-running requests; success is non-deterministic (AC:H). No public exploit code has been identified at time of analysis, and the impact is availability loss, not information disclosure or confidentiality/integrity compromise as some tags or the base CVSS may imply.
Use-after-free and linked-list corruption in the Linux kernel's qla2xxx QLogic Fibre Channel driver can occur when the NVMe-over-Fibre-Channel transport takes the LS-response reject error path in qla_nvme_xmt_ls_rsp(): the uctx structure is freed with kfree() while still linked in fcport->unsol_ctx_head, so a later list_add_tail() writes through the freed node and a subsequent list_del() can corrupt the list or panic the kernel. Affected configurations are hosts running the qla2xxx driver against a QLogic FC HBA with the NVMe-oF FC transport active, primarily enterprise SAN deployments; per the independent assessment this is a local/adjacent, high-complexity issue (AV:L/AC:H/PR:L) whose triggering depends on an error/reject condition on the LS response path rather than directly attacker-chosen input, a notable reduction from the 8.8 input score. There is no public exploit code identified at time of analysis and the flaw is not confirmed actively exploited (no CISA KEV listing); vendor patches are available in the stable trees.
Concurrent list manipulation in the Linux kernel qla2xxx Fibre Channel driver can corrupt the per-fcport NVMe unsolicited-context list, leading to kernel instability or crashes on hosts using QLogic FC HBAs in NVMe-FC mode. The fcport->unsol_ctx_head list is mutated from four different contexts (the response-queue ISR, the DPC/purex worker, the NVMe-FC transport callback and SRB completion) without a shared lock; because multiqueue adapters add entries through different qpairs, the qpair qp_lock cannot serialize the per-fcport list, so a concurrent add/delete or two concurrent deletes can corrupt list pointers. Our independent assessment treats this as a local, high-complexity timing/reliability defect (AV:L/AC:H/PR:L/UI:N, C:N/I:L/A:H) driven by normal NVMe-FC traffic rather than attacker-supplied input - materially lower than the published 8.8 AV:A vector - and no public exploit was identified at time of analysis.
Server-side request forgery in MediaFlow Proxy through 2.4.9 lets remote, unauthenticated attackers force the proxy to fetch arbitrary internal URLs - including loopback services and cloud metadata endpoints such as 169.254.169.254 - and read the full responses back through the d query parameter on the /proxy routes. Two weaknesses combine: the forward route's destination check validated only numeric private/loopback/link-local IP literals, so hostnames like localhost or nip.io-style names that resolve to internal addresses bypassed it, while the /proxy/stream endpoint performed no internal-address check at all, leaving even bare metadata IP literals reachable. No public exploit code has been identified at time of analysis and the flaw is not confirmed as actively exploited (no CISA KEV listing); practical risk depends heavily on deployment, with the highest impact where the instance is internet-reachable and runs in a cloud environment that exposes a metadata service.
Authenticated code injection in Horilla HR (horilla-hr) before 2.0.0 lets any user with access to the HorillaListView export functionality run arbitrary operating-system commands with the privileges of the application process - root, in the project's shipped horilla/horilla-hr Docker image. The issue is rated CVSS v3.1 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H): exploitable remotely over the network with low privileges, requiring only a valid account able to reach the list/export endpoint, with no user interaction and no non-default configuration. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor released a fix in version 2.0.0.
IBM Guardium Data Protection 12.2 stores internal REST service-account credentials in a reversible, plaintext-equivalent format (CWE-256), so an authenticated attacker who can read that stored value can recover the underlying password and mint an administrative REST access token. The flaw is network-reachable but requires a valid low-privileged account (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8) and the ability to reach the credential storage location, which makes it condition-dependent rather than mass-exploitable - SSVC rates exploitation as none and automatable as no, EPSS sits at 0.24% (13th percentile), and no public exploit code or CISA KEV entry is associated with the issue. A vendor patch is available, so the practical risk is concentrated in unpatched 12.2 deployments where low-privileged or delegated accounts exist.
Heap out-of-bounds write in the Linux kernel's hinic network driver (Huawei HiNIC NICs), where check_mbox_seq_id_and_seg_len() permits the final mailbox segment (seq_id=42) to carry a full 48-byte payload, writing 16 bytes past the 2048-byte MBOX_MAX_BUF_SZ receive buffer. The bug is reachable only where the hinic driver is loaded and a mailbox segment can be injected with seq_id=42 and a maximal payload - realistically via the PF/VF hardware mailbox path (for example a malicious VF in an SR-IOV setup) or a compromised device - so per our independent assessment the input CVSS 3.1 score of 8.8 (S:C, C:H/I:H/A:H) materially overstates real-world risk relative to the more realistic AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H profile, which favors a device crash or DoS over reliable code execution. There is no public exploit identified at time of analysis and no CISA KEV listing; vendor patches are available in the stable trees. The sibling hinic3 driver already handled this case correctly via MBOX_LAST_SEG_MAX_LEN, and the same check has now been ported to hinic.
Host root code execution is reachable from inside a Google gVisor sandbox built prior to commit 573a9e73cf844f when the host Linux platform has CUSE (Character Device in Userspace) enabled. A local attacker holding container-image deployment privileges (CVSS PR:L) can embed a /dev/cuse device node in an image; opening it in the sandbox passes through to the host gofer instead of the sentry's emulated device registry, letting the attacker register a host device and abuse CUSE's unrestricted ioctl handling to overwrite root udev helper memory. Exploitation is local and gated on the CUSE-enabled host prerequisite plus the pre-fix passthrough character-device behavior, so default hosts without CUSE are not exploitable; no public exploit code was identified at time of analysis and there is no CISA KEV listing (EPSS not provided).
Privilege escalation in the Knit Pay WordPress plugin through 9.6.1.0 lets an authenticated attacker with Subscriber-level access and above promote their own account to administrator by tampering with the hidden role field of a Gravity Forms submission. The flaw requires the plugin's Gravity Forms integration to be active and a feed configured so that user_role_field_id points at a form field; the plugin then passes that attacker-controlled value directly to WP_User::set_role() with no allowlist validation, and the process is further helped by $0 orders being marked SUCCESS synchronously at submission and by the role-assignment fallback to $lead['created_by'], the submitter's own user ID. At time of analysis no public exploit code or CISA KEV entry was identified, but with CVSS 8.8 and an authenticated low-privilege prerequisite, this is a high-priority issue for any site running the vulnerable plugin together with a configured Gravity Forms feed.
Remote code execution in the WordPress s2Member plugin (all versions up to and including 260814) lets unauthenticated attackers execute arbitrary PHP on the server by injecting code through the 'first_name' parameter, which is substituted unsanitized into an eval'd Signup Tracking Codes template. Exploitation is conditional rather than default-config: the site administrator must have configured a Signup Tracking Codes template containing the documented %%first_name%% placeholder, and the attacker must first obtain the site-global proxy verification key that s2Member exposes in plaintext in the JSON response of any PayPal Checkout AJAX request, which also permits bypassing PayPal postback verification. Both prerequisites together yield unauthenticated remote code execution with high attack complexity and no user interaction; no public exploit code or CISA KEV listing was identified at time of analysis, and no EPSS score was provided.
Cross-site request forgery in Elementor Website Builder (all versions through 4.3.1) lets a remote attacker who holds no credentials of their own induce a logged-in WordPress administrator into silently executing unintended state-changing actions inside the victim's authenticated session. Exploitation requires both a privileged user to be authenticated and that user to be lured onto attacker-controlled content (CVSS UI:R), which caps practical severity despite the high base score of 8.8 reported by the researcher; our independent assessment scores the same vector at C:L/I:L/A:N because the achievable action set is not fully characterised in the advisory. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and no EPSS score or client-side patch detail was supplied in the source data.
Unauthenticated denial of service in Zammad prior to 7.0.2 allows any remote attacker who can reach the host to tie up a Puma request worker for roughly 115 seconds per request by POSTing to /api/v1/import/otrs/import_check. The import_check and import_status actions are missing the setup_done_response guard that other actions in the same controller enforce, so they run against fully set-up production instances, where the code enters a retry loop against a blank OTRS endpoint and sleeps 30 s then 45 s between attempts. Each request costs the attacker almost nothing, so a sustained rate of just a few requests per second saturates the worker pool and keeps the instance unavailable as long as the traffic continues; no account, valid import configuration, or target knowledge beyond the hostname is required, and the CSRF token is trivially harvested from any prior GET response. This is a genuine availability risk that is trivial to trigger, but no public exploit code or confirmed active exploitation has been identified at time of analysis.
A tenant isolation bypass in BerriAI LiteLLM versions before 1.101.0-rc.1 lets an authenticated holder of a valid virtual key read other tenants' entries from the semantic cache and, in the worst case, have attacker-supplied tool calls executed under a victim's credentials. The flaw stems from an inconsistency in how the cache layer derives the tenant scope versus the metadata variable name, so semantically similar prompts sent to routes such as /v1/responses and /bedrock/* can collide with and return another tenant's cached response - potentially exposing PII, financial data, or source code. Exploitation requires a multi-tenant deployment with semantic caching enabled and a sufficiently similar prompt to hit the victim's cache entry, and it is rated CVSS 8.7 with a vendor patch already released (commit 16db51e2, fixed in v1.101.0-rc.1); no public exploit code has been identified at time of analysis and the CVE is not in CISA KEV.
Improper privilege management in Zammad helpdesk/customer support systems allows an attacker holding a valid but deliberately restricted API token to create new administrator accounts, inheriting the latent authorization authority of the token's parent account instead of honoring the token's granular scope. This affects all Zammad releases prior to 7.0.2 and 7.1.0, and exploitation is authenticated (CVSS PR:L) since a scoped token must already be held, though no user interaction is required and the vector is network-reachable; success grants full access to tickets, customers, and configuration and effectively hands the attacker complete control of the instance. No public exploit code has been identified at time of analysis and the issue is not listed as confirmed actively exploited (CISA KEV), but the independent assessment rates it a genuine high-priority privilege-escalation flaw rather than a high-CVSS-but-low-risk case, and EPSS-style risk is elevated by the trivial post-exploitation payoff.
Authenticated administrators of the Zammad helpdesk platform (versions prior to 7.1.2) can achieve remote code execution on the Zammad server by injecting specially crafted text into an AI Agent configuration field that bypasses the application's ERB sanitizer. Because the pre-7.1.2 sanitizer used Ruby's `.sub` and escaped only the first `<%` opener, an attacker with AI Agent create/edit permissions can smuggle a nested ERB tag (e.g. `<%<%= ... %>`) that executes automatically the next time the affected agent processes a ticket, with no interaction from other users required; this yields full read/write/delete access to data on the host (VC:H/VI:H/VA:H). The flaw is a genuine remote code execution issue, not a mislabeled availability problem, and it requires admin-level privileges (PR:H) plus the optional AI Agent feature being in active use; no public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor fix ships in Zammad 7.1.2 (GHSA-gp3x-9xm8-rcj6).
Stored cross-site scripting in GLPI 11.0.6 through 11.0.8 allows an authenticated technician to inject active markup into supplier website fields, which executes in the browser of any user who opens the suppliers list for the affected contact or contract. The vulnerability is fixed in version 11.0.8, and no public exploit identified at time of analysis. Successful exploitation requires a privileged account (PR:H) and user interaction from a victim (UI:P), and the impact is limited to the victim's session context (CVSS 4.0 score 8.5).
Reflected cross-site scripting in Horilla HR (horilla-hr) before 1.6.0 allows a remote, unauthenticated attacker to execute arbitrary JavaScript in the browser of an authenticated employee or administrator by tricking that user into opening a crafted link to /employee/employee-filter-view. The search parameter is written into the DOM through jQuery's .html() in employee/templates/employee_nav.html, so the injected markup is rendered and executed rather than displayed as text; because the payload runs in the victim's session, the attacker can read browser-visible session data and perform actions with the victim's application privileges. There is no public exploit identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV); impact is capped at the client/browser layer (VC:H/VI:H but VA:N and no scope change to the server in the vendor's CVSS 4.0 vector, with our independent assessment scoring CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N).
Insufficient path validation in GLPI's profile-picture update flow lets any authenticated user - including ordinary self-service accounts with no administrative rights - force the application to delete an attacker-selected file on the server's filesystem. Affected releases are GLPI 10.0.0 through 10.0.25 and 11.0.x before 11.0.8; the flaw is fixed in 10.0.26 and 11.0.8. No public exploit code was identified at time of analysis and the issue is not in CISA KEV, but the CVSS 4.0 base score of 8.5 reflects a remote (AV:N), low-complexity (AC:L) attack with high integrity and availability impact once a valid low-privilege session (PR:L) is obtained.
Stored cross-site scripting in the AIL Framework's username timeline lets a remote, unauthenticated attacker execute arbitrary JavaScript in an authenticated analyst's browser by seeding a crafted username - for example an <img> tag with an onerror handler - into a chat or forum that AIL monitors. The malicious username is stored without character restrictions and fires when the analyst hovers over the corresponding timeline entry, because var/www/static/js/d3/timeline_basic.js interpolates the value d.obj directly into D3's html() tooltip without sanitization. CIRCL reports the issue and an upstream fix commit (455dd92c) is available; no public exploit and no CISA KEV entry were identified at time of analysis, and successful exploitation can lead to session hijacking, data exfiltration, or unauthorized actions taken within the analyst's authenticated session.
Stored cross-site scripting in AIL Framework allows an authenticated attacker who can influence matched, tracked, or tagged content to inject HTML or JavaScript into Bootstrap popovers rendered with data-html="true", executing in a victim analyst's session when they view the affected popover. The vulnerability affects versions prior to the fix commit ee63a0a and requires victim interaction (opening the popover, typically on hover); no public exploit code was identified at time of analysis. A vendor patch is available via the referenced commit, but practical risk is moderate given the authenticated attacker prerequisite, required victim interaction, and the niche threat-intelligence context of the tool.
Authorization bypass in the Rattadan Cosmowarp asset_registry smart contract (CosmWasm/Rust) lets any sender execute the privileged UpdateConfig message on deployments where the on-chain config.admin field is unset (None), because the sender-vs-admin check is nested inside an `if let Some(current_admin) = config.admin` block that is silently skipped. Impact is high on integrity and availability (VI:H/VA:H) with limited confidentiality loss (VC:L), scoring 8.4 under CVSS 4.0 and assessed as CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:H; exploitation is only possible against pre-56c6147 builds of the rattadan/Cosmowarp_Contract asset_registry module running with an unset admin, and no public exploit code or active exploitation (CISA KEV) has been identified at time of analysis. The condition is narrow but the consequence is full admin-level config control for whoever submits the transaction first.
Stored cross-site scripting in Zammad prior to 7.0.1 lets an authenticated low-privilege user persist arbitrary HTML markup and JavaScript event handlers inside a ticket title through the normal ticket-creation workflow, because the title is stored without sanitization and later rendered unescaped. The payload fires when a victim - typically a support agent or administrator with an active session - opens the affected ticket or receives a notification, escalation or reminder email that interpolates the title, yielding script execution in the victim's browser context. No public exploit code has been identified at time of analysis, the flaw is not listed as actively exploited, and exploitation requires both an authenticated account with ticket-creation rights and victim interaction; Zammad 7.0.1 contains the vendor fix.
Brute-force attacks against the POST /api/auth login endpoint in Flame through 2.4.0 let remote, unauthenticated attackers submit unlimited password guesses because the endpoint implements no rate limiting, attempt counters, delays, or lockouts. A successful guess yields full administrator access and the ability to modify application configuration. Exploitation requires network reachability to the instance and is only practical against weak or default-style admin passwords - a long, high-entropy password makes guessing impractical (reflected in AC:H/AT:P), and no public exploit code has been identified at time of analysis; instances behind a VPN, an authenticating reverse proxy, or on isolated LANs are not remotely reachable.
Authentication denial of service in RabbitMQ affects deployments running the rabbitmq_auth_backend_oauth2 plugin from 3.13.0 through the fixed releases (4.3.3, 4.2.9, 4.1.14, 4.0.23, 3.13.18), where the JWKS signing-key fetch routine in uaajwt.erl fails to check the HTTP response status code and treats any well-formed HTTP transaction as a success, so a single non-200 response with valid JSON that lacks a 'keys' field wipes all cached signing keys and breaks OAuth2/JWT authentication for every user until the next successful refresh. The vulnerability is remotely reachable and unauthenticated (CVSS:4.0 PR:N / independent CVSS:3.1 PR:N), but exploitation depends on attack requirements being met (AT:P) - the attacker must induce or coincide with an error-returning JWKS response - and the resulting impact is a persistent availability outage (VC:N/VI:N/VA:H in the assessed vector, C:N/I:N/A:H in the independent 3.1 assessment), with no data exposure or code execution. No public exploit code was identified at time of analysis and there is no CISA KEV listing; treat this as a genuine availability threat rather than a top-tier emergency.
OAuth2 client secret disclosure in the RabbitMQ Management UI affects versions 4.2.0 through 4.2.8 and 4.3.0 through 4.3.2, where the configured management.oauth_client_secret is embedded in the JavaScript served by the unauthenticated endpoint /js/oidc-oauth/bootstrap.js. Any party with network reachability to the management HTTP port can retrieve the secret with a simple GET request - authentication requirements confirmed unauthenticated (CVSS:3.1 AV:N/AC:L/PR:N/UI:N) and the assessed impact is high confidentiality loss (VC:H) with no integrity or availability impact. The flaw only manifests when OAuth2 authentication is enabled for the Management UI and the IdP flow uses a confidential client secret, so default or non-OAuth2 deployments are unaffected; no public exploit code has been identified at time of analysis, and the issue is fixed in 4.3.3 and 4.2.9.
A memory-management correctness defect in the Linux kernel's x86 page-attribute code (arch/x86/mm/pat) causes split page tables to be allocated outside the normal kernel page-table path, so they are never marked as kernel page tables and their associated IOTLB entries are not invalidated when the tables are freed. Exploitation requires local, high-privileged access on an affected kernel (the 6.18.7 through 6.18.53 band or 6.19) that also runs an IOMMU with shared virtual addressing (SVA), plus a timing/reuse window in which a stale IOTLB entry is actually consumed; the independent assessment rates the realistic impact as negligible confidentiality impact, limited integrity impact and possible availability impact (CVSS:3.1/AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:L/A:H), materially below the 8.2 vendor-published vector. There is no public exploit identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV), while vendor-released fixes are available in Linux 6.18.53, 7.2.7 and 7.3-rc4.
The RabbitMQ management plugin in versions 4.2.0 through 4.2.8 and 4.3.0 through 4.3.2 writes an 'auth' cookie containing the base64-encoded 'username:password' pair after a successful POST /login, with no HttpOnly, Secure, SameSite, or expiration attributes, so anyone who can read that cookie can trivially decode it back to plaintext administrator credentials. The flaw is not directly exploitable on its own: the attacker must also hold one of three separate primitives - a same-origin cross-site scripting foothold in the management UI, an HTTP-readable network position (cleartext or man-in-the-middle), or local read access to the victim's browser cookie store - which is why the vendor's 8.2 (CVSS 4.0, AT:P/AC:H) score overstates practical risk while the underlying confidentiality impact is high. No public exploit code or confirmed active exploitation was identified at time of analysis, and vendor fixes are available in RabbitMQ 4.2.8 and 4.3.2.
Uninitialized-memory handling in the Linux kernel's Broadcom bnxt_en network driver can leave an rx_tpa[] entry zeroed after a failed TPA buffer reallocation during an RX ring reset, causing a zero DMA address to be handed to the NIC. The bug is not a remotely reachable path: the authoritative assessed vector is CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H, and triggering it requires a host-side memory-allocation failure (-ENOMEM in bnxt_alloc_one_tpa_info_data) to coincide exactly with an RX ring reset on a NetXtreme-C/E adapter with TPA active, so NVD's 8.1 AV:N/PR:N score materially overstates the real risk. Vendor-released fixes exist in 6.12.111, 6.18.53, 7.2.7 and 7.3-rc3, and no public exploit identified at time of analysis.
Linux kernel SCTP timer handling is vulnerable to a time-of-check-to-time-of-use race that can unbalance an association's reference count and cause a use-after-free during association teardown, allowing an unauthenticated remote peer to crash or destabilize an affected system. Any kernel built with the SCTP protocol enabled (CONFIG_IP_SCTP) and exposing an SCTP endpoint to untrusted peers is in scope; the assessed vector is AV:N/AC:H/PR:N/UI:N with no confidentiality impact, low integrity impact, and high availability impact, because winning the narrow timing race is the attacker's main obstacle. There is no public exploit identified at time of analysis and no CISA KEV listing; the upstream and stable-branch fixes are already published, and no EPSS score was supplied in the available intelligence.
The Linux kernel's Reliable Datagram Sockets (RDS) connection teardown path contains a race condition in rds_conn_shutdown() that can crash or hang the kernel, causing denial of service on systems where the RDS subsystem is loaded and connections are being shut down or failed over. The flaw stems from teardown merely sampling the RDS_IN_XMIT and RDS_RECV_REFILL fastpath bits as clear instead of owning them, so a concurrent rds_send_xmit() or rds_ib_recv_refill() can re-acquire the bit and run while the transport re-initializes its rings and rds_send_path_reset() rewrites transmit state under it. Because the store-buffering pattern only manifests where memory ordering is weak (for example ARM), and because the accept-side state check must pass before the path moves to RDS_CONN_DISCONNECTING, reliable triggering is difficult and the practical impact is limited to kernel instability; no public exploit code has been identified at time of analysis and vendor patches are available.
Unauthenticated configuration tampering in Apache Roller 6.1.5 lets any remote attacker persistently rewrite the site-global frontpage weblog selection on a default installation, because the installation-time setup action remains anonymously reachable after setup completes and persists the value without any authorization check. Impact is bounded rather than severe: only one site-global setting is altered, no data is disclosed (C:N), and a global administrator can restore the setting afterward, which is why our independent assessment scores it CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:L rather than the submitted 8.2 high with I:H/A:L. The attack is a single unauthenticated HTTP request with no user interaction, so exposure is broad wherever 6.1.5 is internet-facing; exploitation status is no public exploit identified at time of analysis, and the issue is not tied to any optional feature or non-default configuration.