InvenTree versions prior to 1.4.0 expose the machine restart endpoint POST /api/machine/{pk}/restart/ to any authenticated user, allowing an account holding only low-privilege roles such as STOCK to force registry.restart_machine() against any registered machine. A successful request resets the target machine's status and interrupts active printing, scanning, or other hardware operations, giving an authenticated attacker (PR:L per the assessed vector) a network-reachable denial-of-service against configured machine integrations. Impact is limited to availability (C:N/I:N/A:L, CVSS 4.3); there is no data exposure or modification, and no public exploit code or confirmed active exploitation was identified at time of analysis. Deployments with no registered machines have no exploitable surface.
Path traversal in Joplin Server's transcription proxy endpoints lets an authenticated user on instances configured with TRANSCRIBE_ENABLED=true escape the intended /transcribe/ URL prefix and reach neighboring endpoints on the transcription backend, potentially exposing internal administrative, health, or configuration data. The flaw affects versions prior to 3.7.7; because the CVSS vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N, the attacker must already hold a valid authenticated server session and the only demonstrated impact is limited confidentiality loss - this is a low-to-moderate real-world risk that maps well to its 4.3 score rather than an inflated rating. There is no public exploit identified at time of analysis, no CISA KEV listing, and exploitation additionally requires a reachable transcription backend (TRANSCRIBE_BASE_URL) with adjacent internal endpoints worth reading.
Broken object-level authorization in InvenTree versions prior to 1.4.0 lets any authenticated user, including an account with no assigned roles, read the staged import data and column mappings belonging to another user's DataImportSession by supplying that session's identifier to the /api/importer/row/ or /api/importer/mapping/ endpoints. The impact is confidentiality-only (CVSS 4.4 base, assessed as 4.3: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N) and requires a valid login plus knowledge or enumeration of a victim's session ID on an instance where another user has an active import in progress; no public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV). The vendor's threat model treats authenticated instance users as trusted, so the realistic exposure is between distrustful co-tenants of the same instance rather than remote outsiders, and version 1.4.0 resolves it.
Server-side request forgery in MaxKB 2.10.3-lts and earlier allows an authenticated low-privileged workspace user (CVSS PR:L, no user interaction) to make the MaxKB server issue arbitrary HTTP requests by supplying a URL to the knowledge-base web-document import or synchronization crawler, whose Fork.fork routine calls requests.get with certificate verification disabled and no scheme, loopback, link-local, private, or reserved-address filtering. Because the fetched response body is stored as imported document content, the attacker can read the responses of reachable internal HTTP services or cloud instance metadata (e.g. AWS/GCP IMDS) rather than merely triggering blind requests, making this a full-read SSRF with confidentiality impact. There is no public exploit identified at time of analysis and no CISA KEV listing; the vendor advisory (GHSA-ffxw-frpx-8rww) reports no fixed version, so exploitation requires valid workspace credentials and reachability of interesting internal targets from the MaxKB host.
IP allow-list enforcement in Warpgate 0.23.0 through 0.27.2 is bypassed for HTTP API token authentication: when a user has allowed_ip_ranges configured, a presented X-Warpgate-Token is still resolved into a fully authorized RequestAuthorization::UserToken regardless of the source address, so a leaked, phished, or exfiltrated token can be used from a prohibited network location. Impact is limited to confidentiality of what the token-holding user could already read through the HTTP API (CVSS 4.3, C:L/I:N/A:N) - HTTP target proxying and the SSH, MySQL, PostgreSQL, RDP, VNC, and Kubernetes paths do not accept this token flow, and deployments without allowed_ip_ranges are unaffected. The issue is a remote, authenticated weakness (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N) with no public exploit identified at time of analysis, and it is fixed in Warpgate 0.27.3.
Information disclosure in Apache Airflow's `/assets/events` REST endpoint lets an authenticated user who holds asset-read permission enumerate asset events - source Dag ID, task ID, run ID, timestamps, and total existence counts via pagination - for Dags they have no authorization to read. The endpoint applied no per-Dag readability filter, and because the same filter was missing from the count query, `total_entries` alone revealed the existence of hidden Dags. Affected deployments are apache-airflow versions prior to 3.3.2, and the exposure matters only where per-Dag access control is used to separate teams or tenants; in single-tenant deployments every user is already authorized to see all Dags, so nothing new is disclosed. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV), so this is a modest-severity broken-authorization flaw rather than a high-urgency issue. Vendor-released patch: apache-airflow 3.3.2.
GoCD servers running versions prior to 26.1.0 expose an authorization flaw in the internal UI /jobStatus.json endpoint that lets any authenticated user (CVSS PR:L) enumerate sequential, server-assigned job IDs and read job metadata - job names, state, progress timestamps, assigned agent IP addresses/UUIDs, and the associated stage and pipeline - for pipelines they are not permitted to view. The API fails to verify that the requested job ID actually belongs to the pipeline and stage named in the request (CWE-639), so the disclosure is bounded to metadata only: console output, artifacts, commands, variables, environment data, and configuration are not returned, and the CVSS 3.1 score is consequently 4.3 (low). The issue is fixed in GoCD 26.1.0; no public exploit code was identified and the flaw is not listed in CISA KEV, so there is no indication of active exploitation at time of analysis.
Joplin Server prior to 3.7.7 lets an authenticated low-privileged user who holds a *pending* (not yet accepted) folder-share invitation write new items directly into that shared folder, because ItemModel.checkIfAllowed() accepts any share_users row for the caller without requiring ShareUserStatus.Accepted. The injected content is then pushed out to the share owner and already-accepted participants by ShareModel.updateSharedItems3() before the attacker ever accepts the invitation, giving unauthorized content injection into another user's notebook. The flaw requires the invitation precondition, so it is not exploitable against arbitrary shares or default configurations with no pending invite; impact is integrity-only (CVSS 3.1 base 4.3, C:N/I:L/A:N, PR:L), no public exploit code was identified at time of analysis, and the issue is fixed in 3.7.7.
Principal confusion in Apache Airflow 3.3.0 and 3.3.1 causes core-API requests that carry both a `_token` session cookie and an explicit `Authorization: Bearer` (or OAuth2) credential to execute - and be recorded in the audit log - as the cookie's principal instead of the identity the client explicitly presented, inverting the intended bearer-over-cookie precedence. Exploitation is not automatic: the attacker must first plant a valid `_token` session cookie of their own into the victim's browser or client (for example by cookie tossing from a sibling subdomain, XSS in a separate application sharing the parent domain, or a shared workstation), and the victim's request must simultaneously carry an explicit credential, so only Airflow UI deployments hosted on a domain shared with other applications are reachable this way. The assessed outcome is misattributed audit records and principal confusion (CVSS:3.1/AV:N/AC:H/PR:L/UI:R/C:N/I:L/A:N) rather than direct privilege escalation, and no public exploit code has been identified at time of analysis.
Chat-record management routes in 1Panel-dev MaxKB 2.10.2-lts and earlier authorize only the application_id supplied in the request path, then load chat data using globally scoped chat_id and chat_record_id values without confirming that the chat actually belongs to that application, so a low-privileged authenticated user in the same workspace can read a victim's persisted chat records by re-homing a known chat_id under an application they own. Impact is limited (CVSS 4.2, C:L/I:L), the attack is network-reachable but requires an authenticated normal account in the victim's workspace and prior knowledge or enumeration of valid global chat identifiers, which is the dominant practical hurdle. A second variant uses the add_knowledge flow, available to any user with an owned knowledge base and document, to copy victim answers while overwriting the victim record's improve_paragraph_id_list. No public exploit code has been identified at time of analysis and no fixed version was available as of review; despite the supplied 'Authentication Bypass' tag, this is an object-level authorization/IDOR defect rather than a true auth bypass.
Self-hosted draw.io deployments running the Docker or WAR build prior to 30.2.7 can have a victim's browser session silently bound to the attacker's own cloud-storage identity, because the OAuth callback handler skips verification of the state token against the session cookie whenever IS_GAE is false. An attacker who completes a legitimate authorization for their own account can then induce a victim to open a crafted callback URL, causing subsequent Google Drive, OneDrive, GitHub, GitLab, or Dropbox actions to be performed under the attacker's identity (CVSS 4.2, CVSS:3.1/AV:N/AC:H/PR:N/UI:R, CWE-352); the impact is session integrity loss and misattribution rather than disclosure of the victim's existing cloud files, and no public exploit identified at time of analysis. The hosted SaaS at app.diagrams.net and any Google App Engine build set IS_GAE=true and are unaffected.
Server-side request forgery in Hatchet versions prior to 0.91.1 lets an authenticated tenant of the platform coerce the SNS ingest service into issuing an outbound HTTP request to an arbitrary URL, because the SNS UnsubscribeConfirmation handler calls http.Get() against the payload's UnsubscribeURL even though that field is excluded from the AWS signature verification performed by BuildSignature(). Successful exploitation allows the server to reach internal-only endpoints such as the EC2 Instance Metadata Service, internal HTTP APIs, and other services on the deployment's network, with the practical payoff limited to information disclosure (for example, potentially exposing IAM credentials) rather than code execution or data modification. Exploitation requires the SNS integration to be enabled and reachable and the attacker to already hold a Hatchet tenant account; there is no public exploit identified at time of analysis, and no confirmable tracking in CISA KEV.
Isochronous OUT stream handling in usbredir can leave a stream's single transfer buffer permanently unsubmitted when a transfer count of 1 is used, which defeats the bounds check in usbredirhost_iso_packet() and lets a usbredir peer write beyond the end of the packet descriptor array on every subsequent isochronous packet. The flaw is an out-of-bounds write (CWE-787) affecting usbredir as shipped in Red Hat Enterprise Linux 6 through 10, and the published CVSS:3.1 vector (AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:N/A:H, score 4.1) reflects a local, high-complexity, privileged trigger path whose dominant impact is availability loss rather than code execution. No public exploit identified at time of analysis, and the bug is not listed as confirmed actively exploited (CISA KEV); the realistic risk is materially lower than the raw memory-corruption classification suggests.
Logout on the Apache Airflow Core API revokes only the `_token` browser session cookie and silently ignores a credential presented as an `Authorization: Bearer` header, so an API client that logs out with a bearer token receives the endpoint's normal logout response while its JWT is never invalidated and remains usable until natural expiry (24 hours by default, configurable). Only deployments running Airflow 3.0.0 through 3.3.2 whose API clients authenticate with bearer tokens rather than the browser cookie are affected, and the hard prerequisite is that the attacker already holds a copy of that valid token - obtaining it is explicitly outside the scope of this issue, and no privileges beyond the victim's own are gained. No public exploit code has been identified at time of analysis; the vendor's CVSS 9.1 substantially overstates the exposure, and our independent assessment scores it 4.8 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N) because the flaw only extends a session the attacker could already use, rather than granting new access.
Path traversal in the self-hosted draw.io server (jgraph/drawio) before version 30.2.7 allows unauthenticated remote attackers to redirect the ExportProxyServlet's internal proxy request to unintended routes on the configured export backend by supplying dot segments (literal or percent-encoded) in the request path. Because the servlet copies all request headers and the request body to the traversed destination, an attacker can reach administration, debugging, health, or configuration endpoints that the export server happens to expose, and may trigger unintended internal actions, though the practical impact is bounded by how that backend is configured. Exploitation requires a deployment that has the export proxy feature enabled and pointed at an internal export service; there is no public exploit identified at time of analysis, and no EPSS score was supplied, so the vendor's modest CVSS of 3.7 is a reasonable reflection of real-world risk.
Unconstrained memory consumption in Thinkst Canary's OpenCanary Redis emulation module can be driven by an unauthenticated remote attacker, causing the deception sensor process to exhaust memory and degrade or crash. The issue affects OpenCanary 0.9.9 as reported by Thinkst Applied Research and is availability-only (CWE-770, resource allocation without limits), assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L - a low-severity, low-priority finding. No public exploit code exists and there is no indication of active exploitation (not in CISA KEV), and exploitation requires the Redis honeypot module to be enabled and reachable; the impact is confined to the OpenCanary honeypot process rather than the underlying host, making real-world risk limited.
Denial of service in the Thinkst Canary honeypot's optional Redis service can be triggered by unauthenticated remote attackers when that service is enabled, causing limited availability impact to the Redis service without confidentiality or integrity loss. The Canary is not affected if Redis is disabled, and the high attack-complexity score reflects that the trigger requires specific conditions rather than a reliable full-appliance outage. Thinkst has addressed the issue across supported platforms and published a patched Docker image, with automatic updates already in distribution; no public exploit identified at time of analysis.
Incorrect authorization in GoCD 13.1.0 through versions before 26.1.0 lets an authenticated internal user call the /go/api/support/process_list endpoint without the intended administrator privileges and read command-line arguments, usernames, remote material URLs, and internal material paths for materials they cannot otherwise access. Exploitation is gated by a timing race, since the endpoint only leaks this material metadata while source-control child processes are actively running, and disclosure is bounded because credentials, environment variables, and user-defined secrets remain masked or omitted. No public exploit code or confirmed active exploitation was identified, and the issue is fixed in GoCD 26.1.0.
Unauthenticated remote attackers can inject arbitrary published posts and taxonomy terms into WordPress sites running the To Do List Member plugin through version 1.6, because the plugin's import routine performs neither authorization nor nonce checks and never validates the remote location it fetches data from. The outcome is integrity-only (CVSS 3.7, vector AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) - no disclosure of existing data, no code execution, and no availability impact. No public exploit code has been identified at time of analysis and the plugin is not listed in CISA KEV, so despite being unauthenticated and trivially reachable in principle, this remains a low-real-priority issue, further capped by the plugin's small deployment footprint and the non-trivial setup (hosting or referencing attacker-controlled data for the fetcher to ingest) implied by the AC:H rating.
In Keycloak, a flaw in the User-Managed Access (UMA) permission-ticket flow can cause authorization scopes from two same-named resources owned by different users to be merged, allowing an authenticated attacker to obtain unintended access scopes on a victim's resource. The issue affects deployments where UMA is explicitly enabled and requires the attacker to have an account that can create resources plus a resource-name collision with the victim; it is not a default deployment mode. Independent assessment rates this low severity and confines impact to scope leakage on the specific colliding resource; no public exploit code and no confirmed active exploitation were identified at time of analysis.
Keycloak's client-policy-enforced mandatory 2FA enrollment can be bypassed by an authenticated user who manually triggers a session-restart web link during the login flow, causing the internal markers tracking required authentication steps to be cleared so the session completes with only a password. The flaw only manifests in deployments where an administrator has explicitly enforced step-up/2FA setup through a client policy, and it is a self-bypass by a legitimate password holder rather than a remote compromise; the assessed vector (AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:N) reflects an integrity-only weakening of the authentication posture. No public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV); no EPSS data was supplied.
Information disclosure in Joplin Desktop note rendering: from version 1.4.0 up to (but not including) 3.7.2, the KaTeX renderer runs with the 'trust' option enabled unconditionally, so a note author can embed a KaTeX \href or \url whose target bypasses Joplin's normal Markdown URL allowlist. On Windows, if a victim clicks such a link pointing at an attacker-controlled UNC or file:// path, the operating system attempts SMB authentication and leaks the user's NTLMv2 challenge-response to the attacker without any warning; the same technique can invoke other registered URL handlers (for example vscode:// or ms-msdt:). Exploitation requires a victim running Joplin Desktop on Windows, delivery of an attacker-authored note (shared notebook, sync, or import), and an explicit click on the rendered link, and it is fully fixed in 3.7.2 where KaTeX trust is restricted to http(s), mailto, joplin:// and internal anchor/id schemes; no public exploit code was identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV).
Markup injection in Warpgate's form_post SSO return interstitial (warpgate-protocol-http/src/api/sso_provider_list.rs) affects all versions prior to 0.27.6 and allows an attacker who can influence the `next` redirect parameter or IdP-derived error text to break out of the page's inline redirect script with a script-closing sequence. Because Warpgate's strict Content-Security-Policy blocks injected JavaScript and inline event handlers, the practical impact stops at content spoofing, a fabricated login form, or a meta refresh - not script execution. Reaching the sink requires an authenticated actor with SSO configuration influence (or control of an identity provider / of an email or username claim that the IdP accepts unvalidated), and the victim must actively complete the form_post SSO flow, so exploitation is high-friction; there is no public exploit identified at time of analysis and the issue is rated low severity (CVSS 3.1 base 2.4, assessed vector PR:L). The vendor released the fix in 0.27.6.
Persistent sidebar layout manipulation in the Nextcloud Collectives app allows an authenticated user with page-edit permission to submit oversized text containing line breaks to the page emoji update endpoint, which accepts the value without length or character validation. When another user subsequently views the affected collective page, the unvalidated emoji string overflows and breaks the rendered sidebar, hiding other navigation items from view. The impact is confined to client-side layout integrity with no confidentiality or availability loss (CVSS 3.1/AV:N/AC:L/PR:L/UI:R/S:U/C:N/I:L/A:N, published vector 2.4 with PR:H), making this a genuinely low-risk issue; no public exploit code has been identified at time of analysis, and it applies only where the optional Collectives app is installed.
Authenticated, low-privileged users of GoCD before 26.1.0 can retrieve source-control credentials in cleartext from several read-only pipeline and material APIs whose responses fail to mask the userinfo portion of material URLs. Exposure is narrow: it only affects legacy configurations where an administrator embedded a username and password directly in a material URL, while credentials held in GoCD's dedicated password fields or secret-management plugins stay encrypted and are not disclosed by this issue. The CVSS 4.0 base score of 2.3 reflects the uncommon prerequisite configuration (AT:P) and limited confidentiality impact, and no public exploit code or confirmed active exploitation has been identified at time of analysis.
In Beszel before 0.19.0, any authenticated user - including a read-only account - can create or delete alert rules on monitoring systems they are not authorized to view, because the POST and DELETE /api/beszel/user-alerts handlers fail to verify that the supplied system ID belongs to the caller. Exploitation requires knowledge or guessing of a target system's 15-character PocketBase record ID (reflected in the CVSS 4.0 AT:P prerequisite), which limits practical impact and severity; successful abuse leaks target system names and metrics through the resulting alert notifications and allows unauthorized tampering with alert configuration. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV; the vendor-released fix is Beszel 0.19.0.
Stored cross-site scripting in XXL-JOB (xxl-job) 3.4.2 and 3.5.0 lets an authenticated operator inject script through the job 'name' or 'author' fields in the admin Task Management interface (JobInfoController); the payload is persisted and executes in the browser of any other user who later opens the affected job list or detail page. Publicly available exploit code exists, but exploitation requires an existing admin-console account with job create/edit rights plus interaction from a second user, so the practical risk is assessed as low despite the public disclosure. No confirmation of active exploitation (CISA KEV) is present in the available intelligence.
Local denial of service in Hangzhou Shunwang Technology's shzh 10.7.2.693 (internet-café management software) allows a local, low-privileged authenticated user to crash the host by sending a crafted IRP_MJ_DEVICE_CONTROL request with a manipulated PID argument to the shdrv_x64.sys kernel-mode driver, which mishandles the value and fails to release resources cleanly. The provider records CVSS 4.0 base 4.8 (AV:L/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:L/E:P), while our independent assessment maps the flaw to CVSS 3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, i.e. a local user can fully disrupt availability of the host. No CISA KEV entry or EPSS data was provided, but the vector's exploit maturity value (E:P) indicates publicly available proof-of-concept exploit code exists; because the attack requires an attacker to already have local access to a machine running this specialized software, real-world risk is low-to-moderate.
Eclipse iceoryx2 versions after v0.8.0 up to v0.9.x contain a Rust soundness defect in which StaticString exposes its contents as mutable bytes via safe APIs, and the associated String::as_str() conversion does not validate UTF-8, allowing safe Rust code to construct an invalid &str and trigger undefined behavior. Exploitation requires a local authenticated attacker with low privileges and high attack complexity, and it additionally depends on an application coded in the vulnerable pattern; impact is limited to minor integrity and availability loss with no confidentiality impact, and the defect is not remotely exploitable against a default configuration. No public exploit code or active exploitation has been identified, and the vendor has released a patched version v0.10.0.