Jupyter Server XSRF protection is disabled (disable_check_xsrf set to a truthy value). Disabling XSRF/CSRF checking removes the server's only protection against cross-site and unauthenticated state-changing requests. On tokenless deployments (no token or password configured) an anonymous client can create Jupyter kernels and send execute_request messages con
Rule Explorer
Search the public rule index by CVE, GHSA, CWE, language, framework, author, or rule slug. Filter by language, framework, severity, confidence, license, and validation status.
- Public rules
- 6965
- Downloads
- 12.9M
- Verified
- 6965
- Authors
- 2
An authentication credential is derived from an external identity identifier (e.g. md5($data['id'])) and used to verify or provision a local account. The identifier is often public or guessable, so anyone can reproduce the credential and take over the account through the ordinary password login form. Provision federated accounts with a CSPRNG password, verif
The API credential $T is sourced from the browser-managed `token` cookie, an ambient credential channel, instead of being taken solely from the explicit Authorization header. Browsers attach cookies automatically to cross-site requests, so a cookie-sourced token authenticates CSRF against state-changing management APIs (CWE-352) and the shared token leaks vi
An authentication credential is built from a browser-ambient source (an HTTP cookie or a URL query parameter) and returned for request authentication. Browsers automatically attach cookies to cross-site requests, so every endpoint that trusts this token is vulnerable to cross-site request forgery (CWE-352): a remote attacker page can make a logged-in adminis
Request-controlled data reaches process execution without being resolved against a fixed allowlist. A caller (unauthenticated or cross-site/CSRF) supplies a command string that is tokenized into an argv list and executed (CVE-2026-107337 pattern: a raw URL segment is handed to the service() runner, split on spaces, joined under scripts/ and executed with sub
This request handler deserializes the incoming request with `$CLS.from_request(...)` (which builds the agent run input and leads to an agent run with tool execution) without validating the request Content-Type. Browsers can send cross-origin "simple" POSTs with CORS-safelisted Content-Types (text/plain, multipart/form-data, application/x-www-form-urlencoded)
Destructive delete reachable from a plain GET request: this code path is entered only because a GET/REQUEST parameter is present, and no CSRF token validation or HTTP-method restriction protects the enclosing scope. Authorization relies solely on the ambient session cookie, so a cross-site auto-issuing GET (<img>/<script> src, link, redirect) from a logged-i
Calling loginFromRequestIfNotLogged() followed by isLogged() without verifying whether the session already existed allows CSRF bypass: an attacker supplying arbitrary credentials alongside a victim's session cookie satisfies the isLogged() check without validating the request credentials.
CSRF-able destructive operation: $OBJ is constructed directly from a request parameter ($_POST/$_GET/$_REQUEST) and then destroyed with $OBJ->delete()/$OBJ->remove(), with no CSRF token validation performed first. Ambient session-cookie authentication alone protects this handler, so a cross-site form POST from an attacker page carries the victim's cookies an
CSRF (CWE-352): a PGP 2FA public-key mutation ($CLASS::$METHOD / $OBJ->$METHOD, e.g. LoginControl::setPGPKey) is protected only by ambient cookie-based session authentication. No anti-CSRF token validation is executed between the authentication guard and the key mutation, so a forged cross-site GET/POST carrying the victim's session cookie can silently repla
User session swapping or cancellation is performed without enforcing POST request method or validating a CSRF token. This permits cross-site request forgery (CSRF) via cross-origin requests.
A nonce generated with `wp_create_nonce()` is validated against `wp_verify_nonce()` in the same context instead of verifying the nonce supplied in the request. This causes the verification to always succeed, bypassing authentication and CSRF protections.
Jenkins Stapler web action method performs cache clearing or deletion without `@RequirePOST` or `@POST`. State-modifying endpoints accessible via HTTP GET are vulnerable to Cross-Site Request Forgery (CSRF).
CSRF token (crumb) obtained via issueCrumb() is directly concatenated or embedded into a JavaScript proxy or script template. This allows same-site attackers to extract the victim's CSRF crumb from generated script resources. Use getCrumbExpression() instead.
Same-site/origin decision is made by comparing two results of the same domain/host extraction helper ($F) without first rejecting parser failure. Such helpers return false/null/"" for hosts they cannot parse (long gTLDs, IPv6 literals, missing host), so two unrelated or attacker-chosen origins can satisfy "false === false" and the CSRF/Referer authenticity g
OAuth callback exchanges the authorization code for a token using a client-supplied state ($STATE) that is never validated against a value bound to the initiating browser session. The state parameter is the CSRF boundary of the authorization-code flow: when it is taken from the request (a bound struct field or a query/form parameter) and passed to the token
State-changing API action is executed while same-domain checks are explicitly bypassed without validating the HTTP request method or request origin, leading to CSRF.
Endpoint 'sendEmail.json.php' is included in CSRF bypass list, allowing cross-site request forgery when authenticated administrators visit malicious sites.
The 'netmount' command is omitted from $csrfProtectedCmds in elFinderConnector, allowing cross-site requests to perform network mount operations without CSRF token validation (CVE-2026-81890).
Validating REST API routes using $_SERVER['REQUEST_URI'] when handling 'rest_cookie_invalid_nonce' errors can allow CSRF protection bypass via query parameter injection.
A handler that iterates user-controlled array keys from $_POST/$_GET/$_REQUEST and issues an outbound HTTP/API request with a dynamic URL path does not verify a nonce/capability nor validate the key against a server-side allowlist. PHP preserves '/', '..' and '?' in request array keys, so a key such as "../../routes?x" is interpolated into a relative URL pat
State, CSRF token, or nonce validation function returns :ok in a fallback clause where request parameters are ignored. This allows attackers to bypass validation by omitting required request parameters. Return {:error, ...} instead.
A CSRF/OAuth `state` token read from the request query is validated by a direct ==/!= comparison against a value taken from a session Values map. Query accessors (net/url Values.Get, echo QueryParam) return "" for both a missing and an empty parameter, so replaying the callback with ?state= (or with no state at all) makes both operands "" whenever the stored
SSE or LiveView endpoint is marked @csrf_exempt but does not validate the request Origin header or enforce Content-Type. This allows cross-origin requests to forge state-changing events in authenticated victim sessions (CSRF).