2026-09-16
Unauthenticated remote attackers can abort the `named` process in BIND 9 by sending a crafted DNS-over-HTTPS request that carries a cryptographically invalid SIG(0) record and then prematurely closing the transport connection, producing a null pointer dereference (CWE-476) that terminates the server. Affected versions are 9.20.0 through 9.20.27, 9.21.0 through 9.21.25, and the 9.20.9-S1 through 9.20.27-S1 subscription branch; the assessed CVSS v3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), meaning no authentication or user interaction and availability-only impact. Exploitation requires the targeted named instance to have the DoH transport enabled and to process SIG(0)-signed messages, so server deployments without DoH exposed to the attacker have no reachable attack surface; impact is limited to a process abort with no data disclosure or modification. No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor patches are available (9.20.29 and 9.21.26).
Sandbox escape in Jenkins Script Security Plugin 1415.v9a_f9b_3a_c253d and earlier allows an authenticated Jenkins user who is permitted to define and run sandboxed scripts - including Pipeline jobs - to break out of the Groovy sandbox and execute arbitrary code on the Jenkins controller. The flaw is a protection-mechanism failure (CWE-693): the sandbox's call-site interception does not cover methods that are added dynamically to a class at runtime, so a crafted script can invoke such a method and run code that should have been blocked. Exploitation requires script-authoring privileges (PR:L) and a deliberately crafted script (AC:H) with no user interaction, giving high confidentiality, integrity, and availability impact on the controller; no public exploit code was identified at the time of analysis, and the practical risk is concentrated in multi-tenant Jenkins deployments where lower-trust users are delegated Pipeline authoring.
Arbitrary code execution in the Jenkins Script Security Plugin (versions up to and including 1415.v9a_f9b_3a_c253d) lets an authenticated attacker who holds permission to define classpath entries run attacker-supplied code inside the Jenkins controller JVM. The plugin downloads the URL-specified JAR twice - it verifies approval against the first response but then loads classpath entries from the second - so an attacker who controls the hosting server can present a benign, approvable JAR on request one and a malicious JAR on request two. The assessed CVSS 3.1 vector (7.5, AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H) accurately reflects this time-of-check/time-of-use race: the flaw is remotely reachable but requires an authenticated classpath-defining user and a reliably won race; there is no public exploit code and no confirmed active exploitation identified at time of analysis.
Remote denial of service in ISC BIND 9 lets an attacker-controlled (or spoofing-capable) authoritative DNS server crash a recursive resolver by returning a negative answer of exactly 65536 bytes, which `named` caches as a zero-length entry and later aborts on when the entry is read. The flaw affects 9.11.0 through 9.18.50, 9.20.0 through 9.20.27, 9.21.0 through 9.21.25, and the corresponding -S1 subscription releases, requires no authentication or user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5), and is present in default configurations, though reachability is limited to resolvers that actually recurse against attacker-influenced or spoofable zones and then read the poisoned cache entry. Vendor patches are available (9.20.29 and 9.21.26); no public exploit identified at time of analysis, and the impact is availability-only with no confidentiality or integrity loss.
CPU-exhaustion denial of service in ISC BIND 9 recursive resolvers (9.18.0-9.18.50, 9.20.0-9.20.27, 9.21.0-9.21.25, plus the 9.18.11-S1-9.18.50-S1 and 9.20.9-S1-9.20.27-S1 preview builds) can be triggered by a single remote, unauthenticated query for the root of an already-cached tree of SVCB/HTTPS AliasMode records. Once such an AliasMode chain is resident in the resolver cache, the triggering query causes the resolver to spend disproportionate CPU time constructing the response, degrading or stalling name resolution for all clients of that resolver; impact is availability-only with no confidentiality or integrity effect. The assessed CVSS 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) is well calibrated, but exploitation is conditional on the attacker first causing the SVCB/HTTPS AliasMode tree to be resolved and cached (for example from an attacker-controlled zone) before issuing the trigger query; no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV).
Double free in the Linux kernel's NVMe-over-Fabrics Fibre Channel (nvme-fc) transport lets a privileged local user corrupt kernel memory when an nvme-fc controller creation attempt fails. The bug lives on an error path: nvme_fc_init_ctrl() jumps to out_put_ctrl: when nvme_add_ctrl() fails (reached when dev_set_name() cannot allocate memory), bypassing the pointer clear that nvme_fc_ctrl_free() relies on, so the transport frees the fabrics options and nvmf_create_ctrl() frees them a second time - KASAN reports a slab-use-after-free in nvmf_free_options(). Introduced by commit 1a9e218195a5 and present in kernels from 6.11 through the fixed stable releases, exploitation requires root/CAP_SYS_ADMIN, the non-default nvme-fc transport, and a narrow allocation-failure window (memory pressure or kernel fault injection); no public exploit identified at time of analysis, and the assessment rates availability impact high with confidentiality and integrity impact none.
Linux kernel NVMe zoned-block setup can be forced into an inconsistent state in which a zoned queue is committed with a zero zone size, causing a shift-out-of-bounds (ilog2(0)) and a kernel-side denial of service on the storage I/O path. The flaw affects Linux 6.9 and later kernels with NVMe ZNS support when a zoned namespace's device, firmware, or an attacker-controlled NVMe-oF target answers the Identify Namespace (I/O Command Set specific) or nvme_set_max_append() Identify Controller command with a POSITIVE NVMe status code rather than a negative errno; this requires a host administrator to have attached that device or target, giving an assessed vector of AV:N/AC:H/PR:H/UI:N with high availability impact only. There is no confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis; the issue was discovered by the FuzzNvme fuzzer, and the impact is availability/integrity of the block layer rather than memory corruption or remote code execution.
Remote, unauthenticated denial of service in the Linux kernel's NVMe-over-TCP target (nvmet-tcp) lets a permitted host wedge the target workqueue by racing an unsolicited H2CData PDU ahead of the target's Ready-to-Transfer message. A write command that takes the R2T path is completed twice, causing a response-list entry to point to itself and, depending on CONFIG_DEBUG_LIST, triggering a kernel BUG or an infinite loop/soft-lockup in the nvmet_tcp workqueue. Only hosts configured as NVMe/TCP targets (particularly subsystems using allow_any_host) are affected; no public exploit code has been identified at time of analysis, and the assessed CVSS 3.1 base score is 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H).
A race condition in the Linux kernel's HDMI-CEC subsystem (media: cec) lets a local user who can open a CEC adapter character device (/dev/cecN) and register as an exclusive follower race message delivery against follower mode changes or adapter release, reading the follower pointer without the adapter lock and creating a window that can corrupt kernel state or leak data. The assessed vector (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:H) confirms this is a local, low-privilege issue requiring an actual CEC-capable adapter and precise timing, not the remote/unauthenticated scenario implied by the vendor's AV:A/PR:N score. No public exploit code and no confirmed active exploitation were identified at time of analysis; vendor patches are available across the maintained stable branches.
Kernel crash (NULL pointer dereference) in the Linux kernel's qla2xxx QLogic Fibre Channel HBA driver, in the EDIF (encrypted FC / FC security) RX security-association delete check, allowing a host using that driver and feature to be taken down by a kernel oops in interrupt context. Only systems with a QLogic FC adapter, the qla2xxx driver loaded, and EDIF/FC-SP encryption in use are exposed; the assessed vector is CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:H (integrity and confidentiality unaffected, availability high), which is considerably narrower than the vendor's published AV:N/AC:L/PR:N rating and reflects that triggering the fault depends on a driver-internal abort/return timing race rather than remotely supplied network input. There is no public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV); vendor patches are already released for the affected stable branches.
Server-Sent Events (SSE) sessions in djust versions before 1.0.7 are keyed solely by a client-chosen session_id with no binding to the authenticated user, so an unauthenticated remote attacker who learns or is leaked a valid victim session_id can connect to the message endpoint and dispatch event handlers that execute with the victim's identity and state, rated 7.4 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N, CWE-384). The WebSocket transport enforces this principal binding but the control was dropped on the SSE path, and obtaining a valid session_id first is the limiting factor that accounts for the high attack complexity despite the absence of an authentication requirement (PR:N). Vendor-released patch: 1.0.7, which binds each SSE session to its owning principal, rejects cross-principal access, and caps session creation per principal; no public exploit identified at time of analysis, and the overall risk is moderate-to-serious but not an emergency.
Denial of service in Cisco Secure Firewall ASA and FTD Software allows a network-adjacent, unauthenticated attacker to reload the device by flooding crafted EIGRP update messages, triggering a memory leak that accumulates until the appliance restarts. The flaw is only reachable when EIGRP dynamic routing is configured and active on an interface - it is not present in default configurations - and the attacker must sit within the same Layer-2 broadcast domain/EIGRP adjacency, so the attack cannot be launched across the internet. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; the independent assessment rates this a genuine but bounded availability risk (CVSS 7.4, AV:A/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:H) because sustained, high-rate traffic is required rather than a single packet.
Signature forgery in Sequoia OpenPGP (sequoia-openpgp) stems from incorrect key-flag inference for legacy OpenPGP certificates that lack a key-flags subpacket, letting an unauthenticated remote attacker bypass the back-signature check and bind an arbitrary subkey to their own certificate. This compromises cryptographic integrity for any application that uses the library to verify untrusted certificates, although exploitation requires the victim to process a crafted certificate (UI:R). No public exploit code or CISA KEV entry was identified in the provided data.
Unauthenticated remote attackers can read live Django view and session state and invoke server-side handlers through djust's observability endpoints when a deployment leaves DEBUG enabled and omits the optional localhost-restriction middleware. The exposure requires that specific documented-but-misconfigured combination, which is why the assessed base score of 7.4 carries AC:H despite being network-reachable with PR:N - the endpoints themselves enforced only DEBUG prior to version 1.0.7. No public exploit code has been identified at time of analysis, and the flaw (CWE-306, missing authentication for critical function) is fully neutralized by upgrading to 1.0.7, by setting DEBUG=False, or by installing the localhost-gating middleware.
Stored cross-site scripting in Concrete CMS before 9.5.4 allows an attacker to upload a plain XML document through a publicly reachable Form Block file-upload question; because uploads were validated by extension only and stored as inline-served, same-origin files, the XML can carry an xml-stylesheet processing instruction pointing at an attacker-controlled XSLT stylesheet. When a victim opens the stored file's URL directly in a browser, the stylesheet transforms the document into HTML and runs attacker JavaScript in the Concrete CMS origin - and if that victim is an authenticated administrator, the script acts with the admin session (the reporter demonstrated creating a new user in the Administrators group). Exploitation is conditional rather than opportunistic: the site must expose a file-upload Form Block question and the victim must be lured into opening the hostile file, and no public exploit code was identified at time of analysis; the flaw is fixed in 9.5.4.
Local privilege escalation in the Dell Update Package (DUP) Framework (versions prior to 26.07.03) allows an attacker who already holds low-privileged access on a host to inject operating system commands that execute in the elevated context of the update framework, resulting in high impact to confidentiality, integrity and availability. Exploitation also requires user interaction - a trusted user or an automated process must actually run a Dell Update Package - as reflected in the assessed CVSS 3.1 vector AV:L/AC:L/PR:L/UI:R/S:U/C:H/I:H/A:H (7.3 High), which is local-only and carries no network vector. There is no public exploit identified at time of analysis, and Dell has published a fixed release (26.07.03) in advisory DSA-2026-417.
Uninitialized stack memory in the Linux kernel's LoongArch KVM DMSINTC interrupt-injection path can let a local user who is able to create or control a KVM virtual machine - or code running inside a guest - have non-deterministic stack contents consumed while injecting a dynamic message-signaled interrupt. The vendor rates this 7.3 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N), while our independent assessment keeps the local, low-privilege, scope-changing profile but lowers the impact components to C:L/I:L/A:L because the leaked data is not reliably attacker-controlled; the affected surface is limited to LoongArch hosts with KVM enabled and DMSINTC in use. Vendor fixes are available as upstream stable commits, and no public exploit code or confirmed active exploitation has been identified at time of analysis.
Unauthenticated stored cross-site scripting in the WP-Lister Lite for eBay WordPress plugin affects every release up to and including 3.8.9, allowing an attacker to inject arbitrary JavaScript through the plugin's AJAX cron handler request parameter because input is not sanitized and output is not escaped. The injected payload is persisted and executes in the browser of any user — including administrators — who later views the affected page, enabling session theft, credential harvesting, or full site takeover via an admin session. No public exploit code has been identified and the flaw is not listed in CISA KEV, but the unauthenticated network-reachable attack path makes it a realistic target for automated scanning; an upstream fix was committed in WordPress.org plugin changeset 3638342.
Authenticated users with only read access can delete RBAC relationships in Yeti through 2.11.0, revoking owner grants and locking legitimate owners out of objects. The flaw resides in the DELETE /api/v2/rbac/{id} endpoint, which omits a caller-permission check (CWE-862). No public exploit code or active exploitation has been identified at time of analysis; the assessed CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H) indicates high integrity and availability impact with no confidentiality loss, consistent with a genuine but bounded risk.
Prototype pollution in Builder.io Gen2 SDKs at versions ≤5.2.11 (React, Vue, Svelte, Solid) and ≤0.25.13 (Qwik, Angular, React Next.js) lets an attacker who can supply a malicious content block - for example an authenticated content editor or author with write access to a Builder.io space - inject binding keys containing __proto__, prototype, or constructor paths that the deep-set helper processes during block rendering without validation. The result is pollution of Object.prototype with high integrity impact (VI:H) and limited confidentiality/availability impact (C:L/A:L): every object created later in the same process inherits the tainted properties, so in multi-tenant or shared SSR/rendering deployments one tenant's crafted content can contaminate other tenants' renders. Exploitation requires a low-privileged position (PR:L, CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:H/A:L), and single-tenant sites that render only trusted first-party content have substantially reduced practical exposure; no public exploit identified at time of analysis and the issue is not listed in CISA KEV, making this a genuine but conditional risk rather than a top-tier emergency.
Cross-site request forgery in Yahoo CMAK (Cluster Manager for Apache Kafka) through 3.0.0.6 allows an attacker to make a logged-in operator's browser silently submit forged POST requests that delete topics or change cluster configuration, riding the operator's existing HTTP Basic credentials or play-basic-authentication cookie. The root cause is a confirmed missing CSRF filter combined with an authentication cookie that has no SameSite protection, so no per-request token stands between the forged request and destructive state-changing endpoints. The attacker needs no account of their own, but exploitation does require a valid authenticated operator session plus user interaction (luring that operator to attacker-controlled content), and no public exploit code has been identified at time of analysis.
Path traversal in the Cisco Identity Services Engine (ISE) REST API allows an attacker with valid administrative credentials to write files to arbitrary filesystem locations and ultimately execute commands as root on the appliance. The flaw stems from insufficient validation of file paths in upload or copy operations (CWE-23), and exploitation requires network reachability to the ISE REST API plus high-privileged credentials (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, score 7.2), so it is gated to authenticated insiders or post-compromise attackers rather than unauthenticated outsiders. No public exploit code or confirmed active exploitation was identified in the provided intelligence at time of analysis.
SQL injection in the Tanium Asset module lets a high-privilege authenticated console user execute arbitrary SQL against the Asset data store, with the potential to read, modify, or destroy data the module manages (CVSS 3.1 base 7.2, AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H). The flaw is remotely reachable and requires no user interaction, but it is gated on two conditions: the optional Asset module must be deployed, and the attacker must already hold an elevated Tanium console session - a self-service or low-privilege account is insufficient. Affected builds are Asset before 1.33.326, before 1.36.174, and before 1.39.153; Tanium has released fixed versions and there is currently no public exploit identified at time of analysis, though the EPSS score is minimal and no CISA KEV listing applies.
Authenticated attackers holding a default 'User' role account on Scirius 3.8.0 and earlier can write attacker-controlled JSON files to arbitrary filesystem paths through the PCAP filestore upload endpoint, which derives the destination filename from a user-supplied document _id field. Scored 7.2 both under CVSS 4.0 (CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:H/SC:N/SI:N/SA:N) and CVSS 3.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H), the flaw delivers high integrity and availability impact with no confidentiality loss, and because files are written with a forced .json extension the damage comes from poisoning JSON configuration data or consuming disk rather than planting executable code; if the Scirius service runs as root, writes can land in privileged locations. Exploitation requires network reachability to the upload endpoint plus a low-privileged authenticated account (no user interaction), and no public exploit code was identified at time of analysis, with no CISA KEV listing and no EPSS signal provided in the available data.
Privilege escalation in Red Hat Build of Keycloak allows an account already holding the realm 'impersonation' role to impersonate a realm administrator and thereby seize full administrative control over that realm, including management of users, clients, and roles. Affected builds are 26.4 before 26.4.16 and 26.6 before 26.6.7. This is an access-gated issue rather than a pre-authentication takeover: the CVSS vector (PR:H) confirms the attacker must be an authenticated, privileged sub-administrator or holder of a compromised delegated-admin credential before exploitation is possible, and no public exploit code or confirmed active exploitation has been identified at time of analysis.
Authenticated path traversal in Apache NiFi Registry 0.4.0 through 2.11.0 allows a user who is authorized to both write and delete extension bundles in a bucket to upload a NAR whose manifest carries crafted parent-directory group, artifact, or version coordinates, causing the default file persistence provider to perform file system operations outside the configured persistence directory. Impact is limited to integrity and availability (files created, overwritten, or deleted outside the storage root) rather than confidentiality or remote code execution, and exploitation requires a valid account with write-plus-delete bundle privileges on a deployment using the default file persistence provider. There is no public exploit identified at time of analysis and no CVSS-vector indication of unauthenticated reach; upgrading to Apache NiFi Registry 2.12.0 closes the vector by rejecting parent-directory coordinates and enforcing a normalized strict-child path check.
QDomDocument, Qt's DOM-based XML parser, crashes when processing maliciously crafted XML with extreme element nesting depth, exploiting uncontrolled recursion (CWE-674) to exhaust the call stack and terminate the host application. Any Qt-based application that passes attacker-influenced content to QDomDocument is affected across the Qt version range identified by cpe:2.3:a:qt:qt:*. No public exploit or active exploitation has been identified at time of analysis; the Qt Project has issued a patch via its code review platform.
The @jitsi/electron-sdk package before 10.0.5 bridges the getDesktopSources() API into the meeting page and lets any script running there invoke the jitsi-screen-sharing-get-sources IPC route to pull desktop thumbnails of every screen and window, without a getDisplayMedia() picker being open and without any OS-level screen-recording permission prompt or user consent. The flaw (CWE-862, missing authorization) affects the Jitsi Meet Electron desktop client and any application embedding the SDK, and it is reachable unauthenticated from inside a meeting by a malicious participant or injected script. The vendor fix is a merged upstream PR (PR #516) shipping in 10.0.5; no public exploit code or CISA KEV listing was identified at time of analysis.
Improper validation of parameters in GitLab CE/EE's Terraform state upload functionality allows an authenticated user holding project-level permissions to read restricted file contents on the server or cause denial of service. Affected releases are all versions from 18.2.7 before 19.1.8, 19.2 before 19.2.6, and 19.3 before 19.3.2, with fixes published in the 19.3.2 patch release. Public exploit details exist via a HackerOne report, but the CVSS base score is only 3.1 (AV:N/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:N); there is no CISA KEV listing and no EPSS data was provided.
Premature expiry of multicast forwarding state in Arista EOS can be triggered by a specially crafted packet sent by an unauthenticated attacker who is positioned on the same Layer 2 or otherwise adjacent network segment, causing temporary loss of multicast traffic on the affected interfaces. This is an availability-only denial of service (CVSS 4.0 reports VA:H with VC:N/VI:N; the CVSS 3.1 assessment is AV:A/AC:L/PR:N/UI:N with impact limited to A:H), so the 'Information Disclosure' tag attached to the record does not reflect the actual impact. Exploitation additionally requires that multicast forwarding (PIM/IGMP) is actively configured on the targeted interface - a default, non-multicast deployment is not exposed - and the disruption is transient, since traffic resumes once forwarding state is rebuilt. No public exploit code and no confirmed active exploitation were identified at time of analysis.
Out-of-bounds reads in the Linux kernel's ksmbd in-kernel SMB3 server can leak kernel memory or crash the system when a local low-privileged attacker can influence the netlink IPC share-configuration response produced by the userspace ksmbd.mountd daemon. The flaw lies in unvalidated variable-length share-config fields - an over-long veto list and a path length that fails to account for the separator byte - and affects kernel series where the fix boundaries listed by EUVD are 5.16, 6.2, 6.7, and 6.9, plus the 7.2.6/7.3-rc2 lines. It is not confirmed actively exploited, no public exploit code has been identified at time of analysis, and EPSS is low at 0.19% (9th percentile); a vendor patch is available. Impact is bounded by the fact that ksmbd is non-default on most distributions (which ship userspace Samba) and the vector is local (AV:L) with low privileges (PR:L) and no user interaction.
Server-side request forgery in Nango through version 0.70.4 lets an authenticated user steer server-side HTTP requests to attacker-chosen destinations by supplying malicious values in connection configuration fields that Nango interpolates into provider token and proxy URL templates. Successful abuse can reach internal-only services or cloud instance metadata endpoints (for example 169.254.169.254) and potentially exfiltrate provider credentials held by the Nango deployment. Authentication with the ability to supply connection configuration is required (CVSS 4.0 vector shows PR:L), no public exploit code was identified at time of analysis, and there is no confirmed active exploitation (CISA KEV) - the practical risk is rated moderate because the primary limiter is the pre-existing authenticated access and the payoff depends heavily on the deployment's cloud/network egress posture.
Server-side request forgery in Coze Studio through version 0.5.1 allows an authenticated user who can register or configure a plugin tool to supply an arbitrary server URL, causing the backend to issue HTTP requests to internal-only destinations on the attacker's behalf. The primary risk is confidentiality rather than code execution: responses from cloud metadata endpoints (for example 169.254.169.254) or other services reachable only from the backend network can be read back through the plugin mechanism, potentially exposing credentials, tokens, and internal service data. The issue is rated 7.1 in the CVSS 4.0 vector published with the CVE, while the independent assessment scores it as a credentialed SSRF (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) with no integrity or availability impact; no public exploit code was identified at time of analysis and no CISA KEV listing applies, so this is a moderate-priority, credentialed SSRF rather than a critical remote-takeover flaw.
Server-side request forgery (SSRF) in Graylog through version 7.1.4 allows an authenticated user who holds lookup table or event notification permissions to coerce the Graylog server into fetching internal services. The flaw occurs because Graylog validates outbound URLs against an allowlist only before the initial request and does not re-validate the destination after an HTTP redirect; an attacker can supply an allowlisted endpoint that redirects to an internal address, and the server returns the internal response. This is a confidentiality-only issue (CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) with no public exploit identified at time of analysis.
Trigger.dev before 4.6.0 allows an authenticated low-privilege user to bind an arbitrary GitHub App installation to their own organization, because the platform does not verify that the user controls that installation. By replaying a valid OAuth state cookie and supplying sequential GitHub App installation identifiers, an attacker can gain unauthorized access to the victim's repositories in multi-tenant or shared self-hosted deployments where multiple organizations connect GitHub Apps. Exploitation requires winning a timing race and is not push-button; no public exploit code or active exploitation has been identified at time of analysis.
Authorization bypass in Leantime before 3.9.6 lets authenticated users with limited roles install marketplace plugins through an HTMX plugin-install endpoint that does not validate permissions. Because attacker-controlled plugin metadata such as identifier, version, and license key can be supplied, a low-privileged account could deploy a malicious plugin, resulting in high integrity impact with limited confidentiality and availability effects. The issue is role-gated rather than anonymous, no public exploit has been identified at time of analysis, and Leantime 3.9.6 is available as the vendor fix.
Twenty CRM before 2.35.0 fails to enforce field- and row-level permission checks inside the groupBy-with-records GraphQL resolver, letting an authenticated user who holds canReadObjectRecords permission read field values they are explicitly denied by canReadFieldValue. The result is read-only disclosure of restricted record data to a partially privileged account - no modification or denial of service - and no public exploit code has been identified at time of analysis. The vendor has shipped a fix in version 2.35.0, and the flaw carries a CVSS 4.0 base score of 7.1 (our independent assessment scores it CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), reflecting a genuine but moderate-severity authorization defect rather than a high-severity emergency.
Cross-tenant information disclosure in ArcherySec through 2.0.6 allows any authenticated user to read web vulnerability findings belonging to other organizations by supplying arbitrary or enumerated scan identifiers to the WebScanVulnList endpoint, which performs no organization-ownership check. Rated 7.1 (CVSS 4.0) and mapped to CWE-639, the flaw is a classic IDOR/BOLA: exploitation is remote and low-complexity and requires only a valid low-privilege login (PR:L per the assessed vector), with impact confined to confidentiality (full read of titles, severities, statuses and analyst notes) and no modification or denial of service. Risk is materially higher on shared multi-tenant deployments where several organizations coexist on one instance; single-organization installs have no other tenants to leak from, and there is no public exploit identified at time of analysis.
Information disclosure in Shlink through 5.1.6 allows an attacker who already holds a role-restricted API key (author-only or domain-only) to read visit analytics - referrer, user agent, geolocation and full short-URL objects - for links outside that key's authorization boundary. The mercure-info endpoint mints a Mercure subscription JWT without applying the API key's role restrictions, so the scoped credential can subscribe to every topic rather than only its own. Exploitation is authenticated (CVSS vector PR:L, matching the independently assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) and additionally requires Mercure real-time updates to be configured and enabled on the target deployment; impact is confidentiality-only with no integrity or availability effect, and no public exploit identified at time of analysis.
Information disclosure in SecObserve versions 1.17.0 through 1.59.0 allows an authenticated, low-privileged user holding only view-only membership in a product to read the decrypted HTTP basic-auth password stored for scanner or integration service accounts. Because the ApiConfigurationSerializer fails to strip the basic_auth_password field from API responses, the secret is exposed through standard REST endpoints to any account with `reader` rights; no administrator privileges, user interaction, or special configuration are required beyond the existence of at least one basic-auth-configured integration. Impact is confined to credential confidentiality (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/C:H/I:N/A:N), and no public exploit code or confirmed in-the-wild exploitation has been identified at time of analysis. This is a genuine but bounded credential-disclosure issue, best treated as a medium-priority patch rather than an emergency.
Authenticated users holding any valid PatrowlManager account (CVSS PR:L) can read platform-wide event history, delete arbitrary events, and modify alerts belonging to other users in PatrowlManager through 1.8.4, because the events and alerts API endpoints perform no ownership filtering (CWE-862). The flaw requires only a low-privileged login with no user interaction or special configuration, yielding high integrity impact (VI:H) and limited confidentiality exposure (VC:L). No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and the platform's niche deployment footprint limits realistic exposure, though any multi-tenant installation is at risk of cross-user data tampering.
Authenticated users on Harness deployments through version 3.3.0 can read infrastructure provider configurations from spaces they do not belong to, because the GET /api/v1/infraproviders endpoint fails to validate space-level access control (CWE-862). Exploitation requires only a valid low-privilege account (CVSS v4.0 PR:L, and the independent assessment rates it PR:L as well), so it is realistic mainly on multi-tenant or multi-space instances where the attacker's account lives in a different space than the targeted provider records; a single-tenant instance with no untrusted users has limited exposure. The result is a confidentiality-only impact (VC:H, no integrity or availability effect) exposing sensitive provider metadata such as Docker endpoints, TLS certificate paths, and cloud project identifiers. No public exploit identified at time of analysis, and the issue is not confirmed actively exploited (CISA KEV). Note: the supplied CVSS v4.0 base score of 7.1 and the independent CVSS v3.1 assessment (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) agree on the authenticated, network-reachable, read-only nature of the flaw.
SQL injection in Cisco Identity Services Engine (ISE) 3.1.0 through 3.5 lets an authenticated attacker with low-privileged administrative credentials read or modify data in the underlying database by sending a single crafted request to the management interface; no user interaction is required and the vector is network-reachable (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:H/A:N, 7.1). Because exploitation is gated behind valid administrative credentials, the practical exposure depends heavily on how tightly ISE management and API interfaces are restricted to trusted admin networks. Integrity impact is rated High while confidentiality is Low and availability is unaffected, so the realistic worst case is unauthorized tampering with - rather than mass exfiltration or denial of service of - ISE-stored data; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV).
Malformed IGMP packets sent by a network-adjacent, unauthenticated attacker can terminate the IGMP snooping agent on Arista EOS switches, causing multicast traffic to flood to all ports of the affected VLAN until the agent recovers. Because IGMP snooping is enabled by default on all VLANs in EOS, most deployments are exposed out of the box, but the attacker needs Layer 2 adjacency to a target VLAN (a compromised host, rogue device, or insider on the switched segment) rather than arbitrary internet reachability, and the impact is a bounded, self-recovering availability disruption that must be repeatedly triggered to be prolonged. No public exploit code and no confirmed active exploitation were identified at time of analysis; the realistic risk is a genuine but non-critical availability concern rather than a priority-one emergency.
Denial of service in Open5GS up to and including 2.8.0: a crafted PFCP message that declares a Volume Measurement information element shorter than the fields the parser actually reads causes a null pointer dereference in ogs_pfcp_parse_volume_measurement in lib/pfcp/types.c, aborting the affected SMF/UPF process and disrupting the 5G core user-plane control path. The attack is launched remotely by sending malformed PFCP signaling to the N4 interface, which in a correctly segmented deployment is an internal control-plane segment rather than an internet-facing service; the vendor's CVSS 4.0 vector scores it 7.1 with PR:L, while our independent assessment scores 7.5 (CVSS 3.1, AV:N/AC:L/PR:N/UI:N, availability-only impact) because Open5GS's PFCP implementation does not enforce authentication. An upstream fix commit (8f07b507b78ff94776f2cd49276eb116ed93d7f2) is published, and no public exploit code or confirmed active exploitation has been identified at time of analysis.
Broken object-level authorization in DFIR-IRIS (iris-web) through 2.4.29 lets an authenticated user who has legitimate access to just one case read comment threads belonging to cases they are not authorized to see, by enumerating sequential object identifiers against the comment-listing endpoints for notes, tasks, IOCs, assets, and evidence items. The flaw is a classic IDOR (CWE-639) with confidentiality-only impact: the attacker can read but not modify or delete data, and exploitation requires a valid session with PR:L privileges - it cannot be triggered by an unauthenticated outsider. No public exploit code has been identified at time of analysis and there is no CISA KEV confirmation of active exploitation, though the sequential IDs make the attack trivial to automate for anyone holding a low-privileged account in a multi-case deployment.
Authorization bypass in ContiNew Admin through 4.1.0 allows any authenticated user to delete other users' personal messages and announcements by submitting arbitrary identifiers in the IdsReq parameter to the personal message delete endpoint in UserMessageController. Because the pre-patch MessageServiceImpl.delete() called baseMapper.deleteByIds(ids) without verifying ownership, the attacker can remove any message row and also purge all recipients' read receipts for those messages. Impact is integrity-only (CVSS 3.1 assessed: AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N; vendor-published CVSS 4.0 score 7.1, VI:H), requiring only a valid low-privileged account with no admin role and no user interaction; no public exploit code was identified at time of analysis.
Authenticated users of TDuck Survey Form through version 5.3 can hijack forms they do not own and redirect their submissions to arbitrary destinations, because WebhookConfigController enforces neither a form-ownership check nor any validation of the webhook URL. The result is a chained broken-access-control/IDOR plus server-side request forgery issue: a low-privilege account can point a victim's webhook at an external collector to exfiltrate form data, or at internal-only addresses to make the TDuck server issue requests on the attacker's behalf, producing high confidentiality impact with only limited integrity impact. Exploitation needs only a valid authenticated session (remote, no victim interaction beyond normal form submissions, no non-default configuration), and no public exploit code or confirmed active exploitation was identified at time of analysis.
Improper access control in stylefeng Guns through 8.3.5 lets any authenticated user, even one with no assigned roles, create, edit, delete, publish, and retract system-wide notices via SysNoticeController actions that never require a permission. The issue is remotely exploitable with low privileges and high integrity impact but no confidentiality or availability impact; no public exploit code has been identified at time of analysis, and authentication is required (PR:L) because the attacker must already have a valid Guns session.
Missing authorization in the Guns Java rapid-development framework (through 8.3.5) allows any authenticated user to harvest the full user directory, including account names, real names, email addresses, phone numbers, last-login IPs and role assignments. The /sysUser/detail and /sysUser/page handlers in SysUserController omit the requiredPermission annotation, so the TokenAndPermissionInterceptor performs no RBAC check on them and returns data for every user in the system to anyone holding a valid login token. The attack is network-reachable and needs only a low-privileged authenticated session (PR:L), with no user interaction and no administrative rights; no public exploit code or confirmed active exploitation has been identified at time of analysis, and no EPSS score was supplied in the source data.