Path traversal in Prisma Cloud Checkov enables an unauthenticated local attacker to write files to arbitrary locations on the scanning filesystem by persuading a victim to scan attacker-controlled or untrusted infrastructure-as-code content. Exploitation requires user interaction (the victim running Checkov on malicious IaC), and the flaw is not remotely exploitable; impact is limited to file writes on the host performing the scan. No public exploit code or active exploitation has been reported (CISA KEV does not list this CVE), and the practical risk is low, especially for environments that scan only trusted, internally-authored IaC.
Nix releases before 2.35.3 in unsandboxed macOS or FreeBSD deployments permit a local authenticated build user to establish daemon client connections that should be denied, enabling unauthorized interactions with the Nix daemon. The independently assessed CVSS is 4.3 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:N), reflecting a local, scope-changed authorization weakness with limited integrity impact and no confidentiality or availability impact. No public exploit identified at time of analysis; the issue is confined to unsandboxed macOS/FreeBSD configurations, and upgrading to 2.35.3 or enabling sandboxing removes the exposure.
Seatbelt sandbox escape on macOS in Nix before 2.35.3 and Lix before 2.95.4 lets a local attacker cause a crafted build to break out of the macOS Seatbelt confinement via a mishandled size threshold, yielding limited integrity impact (C:N/I:L/A:N). There is no public exploit identified at time of analysis and no confirmed active exploitation, and the issue is assessed as low-to-moderate priority because exploitation requires local access on macOS plus the ability to have a build evaluated on the host, such as on multi-user build servers or CI runners processing untrusted derivations. Unauthenticated local access is consistent with the CVSS vector (PR:N).
Type confusion in the Palo Alto Networks GlobalProtect app on Windows lets an authenticated local user with low privileges crash the client and produce a denial-of-service condition (CWE-843; vendor CVSS 4.0 score 4.3; assessed CVSS:3.1 4.3 with AV:L/PR:L/UI:N and availability-only impact). Only the Windows client is affected - GlobalProtect on Linux, macOS, iOS, Android, and Chrome OS is explicitly not vulnerable - so the exposed population is limited to Windows endpoints running GlobalProtect 6.3.0 before 6.3.3-h16, 6.2.0 before 6.2.8-h15, or 6.0.0 before 6.0.15. There is no remote attack surface, no confidentiality or integrity impact, and no privilege escalation or lateral movement, and no public exploit code was identified at time of analysis. Vendor-released patches are available, so this should be treated as a low-to-moderate priority maintenance item rather than an emergency.
WebAuthn two-factor authentication in LDAP Account Manager (LAM) before 9.6 fails to clear the WebAuthn challenge from the PHP session after the authentication response is processed, allowing a signed WebAuthn ceremony state to be replayed rather than consumed once. Exploitation requires an attacker who already holds valid account credentials (the CVSS vector shows PR:L, i.e. authenticated), operates within the same PHP session, and can present a valid authenticator signature, and it only affects non-default installations where WebAuthn 2FA is enabled - this is a low-priority 2FA weakness rather than an anonymous remote compromise. No public exploit code or confirmed active exploitation has been identified at time of analysis.
An out-of-bounds read in the Zephyr RTOS STM32WBA IEEE 802.15.4 driver (drivers/ieee802154/ieee802154_stm32wba.c) lets an attacker within radio range of an STM32WBA-based device copy roughly 128 bytes of adjacent RAM into a network packet delivered to the networking stack. The flaw affects Zephyr 4.3.0 through 4.4.2 in the default production configuration (CONFIG_ASSERT=n), where the only length bound is compiled out; builds with CONFIG_ASSERT=y are not exploitable because the assertion would fire first. Impact is limited to a read-only information disclosure and oversized packet allocation in the RX thread - no code execution and no internet-reachable path - and no public exploit identified at time of analysis, with CVSS scored 4.2 (AV:A/AC:H/PR:N/UI:N).
Local privilege escalation in Nix before 2.35.3 allows a local attacker with access to the user account that installed the multi-user Nix store to gain root privileges by tampering with /nix/store contents, because the installer incorrectly assigned ownership of the store to the invoking user instead of root. The independent assessment rates this as High severity (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), noting that exploitation requires local access to the affected account and that the host must have been provisioned with the vulnerable multi-user installer. No public exploit code is known at this time; a security advisory is available.
Command injection and buffer overflow weaknesses in HPE NonStop Java JToolkit can let a locally positioned, already highly privileged attacker corrupt memory or execute unintended commands within the JToolkit process, with impact limited to low confidentiality, integrity, and availability effects (CVSS 3.1 base 3.8, Low). Exploitation is not remote: it requires pre-existing high local privileges (PR:H), local access to the NonStop system (AV:L), a separate user interaction that supplies attacker-influenced input to the vulnerable routine (UI:R), and additional non-deterministic conditions captured by high attack complexity (AC:H). No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (no CISA KEV listing), so all available CVSS signals point to a low real-world priority.
Request-line injection in cpp-httplib 0.29.0 through 0.50.x lets a caller-controlled path that reaches Client::open_stream() - or any client path when set_path_encode(false) is in effect, such as a decoded redirect Location - carry raw CR/LF bytes into detail::write_request_line() and split the outbound HTTP/1.1 request line, injecting attacker-shaped request metadata that a downstream backend or intermediary may honor. The library itself requires no authentication (CVSS vector PR:N), but practical exploitation needs two coinciding conditions: the embedding application must forward remote input into that unsanitized path, and the receiving server or proxy must interpret the injected bytes as header or request boundaries. Impact is integrity-only (I:L) with no confidentiality or availability effect, no public exploit code has been identified at time of analysis, and the vendor fix is released in 0.51.0, making this a low-priority defense-in-depth issue rather than an urgent threat.
Authentication rate-limit bypass in Zimbra Collaboration Suite 10.1.0 through 10.1.21 enables remote, unauthenticated attackers to use GraphQL aliases to pack multiple password guesses into a single HTTP request without incrementing Zimbra’s source-IP failure counter, weakening brute-force and credential-stuffing protections. The flaw does not itself grant account access: successful compromise still requires guessed or stuffed valid credentials, and the independent assessment notes that valid MFA, strong unique passwords, WAF inspection of GraphQL alias abuse, or restricting portal exposure can materially reduce impact. Signals are mostly low and largely consistent, but the raw CVSS understates the operational risk; no public exploit was identified at time of analysis, though Rapid7 has published research on the issue.
Path traversal in UniFi Protect AI Key allows unauthenticated, network-reachable attackers to obtain limited information about files on the device, but exploitation requires high attack complexity and specific conditions per the vendor. No public exploit code or active exploitation has been identified at time of analysis. The CVSS score is 3.7 (Low), reflecting the difficulty of exploitation and the restricted confidentiality impact.
A path traversal write/truncate primitive in Ubiquiti's UniFi Protect AI Key lets unauthenticated attackers who already have network reachability to the device create or truncate files on it when specific, attacker-uncontrolled conditions are met. Impact is limited to integrity (CVSS 3.1 score of 3.7, AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) - no code execution, data disclosure, or availability loss is claimed - and the high attack complexity points to a required precondition such as a race condition or a particular device state. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing); Ubiquiti's Security Advisory Bulletin 070 is the authoritative reference.
FileRise deployments prior to 3.20.0 expose the /api/file/snippet.php short-text preview endpoint without the standard authenticated-session guard, allowing unauthenticated network requests to reach ACL evaluation rather than receiving an immediate 401. On default, correctly configured installations the ACL checks still block access, so arbitrary file read is not possible; actual short preview content disclosure requires an additional non-default reverse-proxy header configuration or ACL misconfiguration, making the assessed real-world risk LOW (CVSS 3.7). No public exploit identified at time of analysis.
Out-of-bounds read in Godot Engine through 4.7.2 lets a crafted .translation resource drive a hash-table offset far past the allocated bucket table in OptimizedTranslation::get_message, so that loading the resource and performing a tr() string lookup either crashes the Godot editor or an exported game or returns raw heap bytes from elsewhere in the process as the 'translated' string, disclosing process memory. Exploitation is local and requires user interaction - the crafted translation file must be delivered into the project or game and then a lookup performed against it - and reliable heap disclosure depends heavily on process memory layout, so a crash is far easier to trigger than a useful leak; there is no public exploit identified at time of analysis. The report is disputed by the supplier, which argues loading untrusted resource files sits outside Godot's current threat model, and the assessed CVSS of 3.6 (AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:N/A:L) reflects a genuinely low real-world risk rather than a remote or wormable issue.
Removing two packages in a single BusyBox dpkg invocation can silently drop the second package's stanza from the dpkg status file when the first package's stanza is larger than the second, leaving the package database inconsistent with what is actually installed. Only environments that compile in and actually use the BusyBox dpkg applet are affected - Red Hat lists Red Hat Hardened Images, whose minimal footprint typically relies on BusyBox applets, and any other image built with CONFIG_DPKG enabled. The assessed vector (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:N, score 3.3) requires local execution plus a human performing the removal, yields integrity-only impact on the status file with no confidentiality or availability effect, and no public exploit or code execution path has been identified at time of analysis.
Support bundles generated by talosctl on Talos Linux releases prior to 1.12.9 and 1.13.3 include the registry 'auth' field from registryconfigs.cri.talos.dev.yaml and sensitive file content from etcfilespecs.files.talos.dev.yaml without marking or redacting them, so an operator who hands such a bundle to an unintended recipient can expose private container-registry credentials and configuration secrets. The flaw is a locally triggered information-disclosure issue rated CVSS 3.3 (AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N): exploitation requires an operator to produce the bundle and deliberately share it, and the real-world impact depends on the network exposure of the leaked registry and the privileges of the exposed credentials. No public exploit code or confirmed active exploitation has been identified, and the issue is fixed in 1.12.9 and 1.13.3.
Information disclosure in the VeraCrypt Windows kernel driver (veracrypt.sys) in version 1.26.29 and earlier allows a locally authenticated, low-privileged user to supply crafted object-manager or device paths to the TC_IOCTL_GET_RESOLVED_SYMLINK, TC_IOCTL_GET_DRIVE_PARTITION_INFO, VC_IOCTL_GET_DRIVE_GEOMETRY_EX, and legacy TC_IOCTL_GET_DRIVE_GEOMETRY handlers, causing src/Driver/Ntdriver.c to perform kernel-context symbolic-link and disk-device lookups outside the intended VeraCrypt workflow scope. Successful abuse discloses only low-sensitivity metadata - drive-letter targets, partition information, disk geometry, GPT/MBR state, and limited object-manager path metadata - with no integrity or availability impact, which is why the issue carries a low CVSS 3.3 (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N). Exploitation is strictly local, requiring an interactive session or code execution as any user account on a host running an affected driver; no public exploit code identified at time of analysis, and the issue is fully neutralized on hosts updated past the upstream fixing commit.
Integer overflow (CWE-190) in the rapidcsv C++ header-only CSV parser prior to version 8.99 allows a local attacker to corrupt heap memory or crash a process that loads an attacker-supplied CSV into an in-memory matrix. The affected APIs - RemoveColumn, InsertColumn, RemoveRow, InsertRow, and GetColumnNames - cast a size_t index to int before adding it to a std::vector iterator, so on 64-bit systems an index above INT_MAX wraps negative and points before the start of the buffer. Exploitation prerequisites are severe: the process must hold a matrix with more than 2^31 elements in a row or column (tens of gigabytes of RAM) and then call one of those APIs, so ordinary CSV workloads are not practically affected. No public exploit identified at time of analysis; the CVSS base score is 2.9 (AV:L/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L), and the fix is the vendor-released patch in v8.99.
A heap out-of-bounds write in Godot Engine through 4.7.2 is reachable when the engine (or an exported game built with it) loads a specially crafted binary resource file (.res). A negative Unicode-string length field read from the file bypasses the buffer-resize check and is then sign-extended into a very large unsigned copy count, causing file-controlled data to be written far past an undersized heap allocation. The attack is local and requires the victim to open a malicious .res file in the editor or to load it at runtime in a game that ingests external assets such as mods or user-supplied content, and reliable code execution demands heap grooming (high complexity); no public exploit code and no confirmed active exploitation were identified at time of analysis. Note that the supplier disputes the security relevance, arguing that loading untrusted resource files is outside Godot's threat model, whereas independent assessment rates the confidentiality, integrity and availability impact of a successful trigger as High.
Heap out-of-bounds write in the Radiance HDR (.hdr) image decoder of Godot Engine through 4.7.2 allows an attacker-supplied .hdr file to corrupt heap memory with contents and overflow length controlled by the file, during project import or runtime image loading. The vendor's CVSS 3.1 vector places this at local, high-complexity, user-interaction-required, unauthenticated (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:L per the independent assessment), because the victim must import or load the crafted file and success depends on heap layout. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor disputes that attacker-supplied asset delivery is inside the current Godot threat model, leaving real-world priority LOW.
Authenticated Papermerge Core users can query the GET /tags/all and GET /document-types/all endpoints with a group_id parameter to read tag and document-type metadata belonging to groups they are not members of. The flaw is a missing authorization check (CWE-862) present through version 3.5.3: those routes omit the user_belongs_to membership validation, so anyone who already knows a target group's UUID receives the group's tag and document-type listings instead of a 403. Exploitation requires a valid low-privileged account plus prior out-of-band knowledge of a foreign group's UUID (CVSS 4.0 AT:P, PR:L), the impact is read-only metadata disclosure limited to low confidentiality (no document content, no writes), and no public exploit code or confirmed active exploitation has been identified at time of analysis.
Information disclosure in Dell OS Recovery Tool versions prior to 2.4.4 allows a low-privileged local account, combined with physical access to the machine and user interaction with the tool, to read sensitive information that the application stores insecurely on disk. The exposure is limited by design: the attack vector is physical (AV:P), authentication is required at the low-privilege level (PR:L), and the only impact is Low confidentiality (C:L) with no integrity or availability effect, producing a CVSS base score of just 2.2. There is no public exploit code identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV); remediation is available by upgrading to Dell OS Recovery Tool 2.4.4 or later per Dell DSA-2026-450.
Loading an untrusted safetensors model file into ExLlamaV2 up to and including 0.3.2 triggers a heap buffer overflow in the Safetensors Tensor Loader, because STFile.get_tensor in exllamav2/stloader.py acts on the data_offsets value from the model header without validating that it stays within the mapped buffer. The path is network-reachable and requires no credentials (PR:N), but it is gated by user interaction (UI:P, CVSS 4.0) - an attacker cannot hit a passive inference server, only one that is actually made to load a malicious or tampered third-party model. Publicly available exploit code exists and no CISA KEV entry is associated, so this is a proof-of-concept-driven issue rather than confirmed in-the-wild exploitation; the vendor-assessed CVSS 4.0 score is 2.1 (Low), and our independent assessment lands at a similar Low real-world priority because the realistic outcome is denial of service or limited memory corruption rather than reliable remote code execution.
An out-of-bounds write in the Whisper speech-recognition model loader bundled with Praat (external/whispercpp/whisper.cpp) is triggered when a user loads a crafted Whisper model whose tensor dimension count (n_dims) falls outside the expected 0-4 range, corrupting memory on the local system. Affected versions are Praat up to and including 7.0.02; exploitation requires user interaction - the victim must actively open the malicious model file - and no authentication is required, with impact limited to low confidentiality, integrity, and availability loss on the local host. Publicly available exploit code exists, but the issue is rated low priority given the local attack path and the required user action, and no data indicates confirmed active exploitation.
Denial of service in sgl-project SGLang up to 0.5.19 allows remote attackers to crash request handling by submitting a malformed session_params object to the generate endpoint, where a field such as id, rid, offset, replace, or drop_previous_output is supplied with the wrong data type. Because SessionParams is constructed without type validation in vulnerable builds, the mismatched type raises an uncaught TypeError that aborts the affected request path; no data exposure or code execution results. Publicly available exploit code exists (a reproduction script is linked in the references) and the vendor was reportedly notified via an issue but had not responded at the time of disclosure; the issue is low severity (CVSS 2.1/3.1 score of 2.1 with A:L, E:P) and affects availability only.
Reflected cross-site scripting in ClipBucket v5 (through 5.5.3-#206) allows an attacker to have arbitrary HTML and script executed in the origin of the admin panel by luring a logged-in administrator into submitting a forged cross-site POST to admin_area/index.php with mode=add_todo and a malicious val parameter; the endpoint carries no CSRF token, and the val value is echoed back through nl2br() without output encoding. The attacker requires no authentication of their own (PR:N in the published CVSS 4.0 vector), but exploitation is not self-executing: it depends on an active administrator session and on that admin being convinced to submit the crafted request (UI:A), and the consequence is script execution inside the admin panel origin rather than direct server compromise. No public exploit code was identified at time of analysis and there is no evidence of active exploitation; scoring is low (CVSS 4.0 base 2.1; independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N), making this a genuinely low-priority finding whose risk is bounded by the required victim interaction and privileged session.
Heap- and stack-based buffer overflow in HPE NonStop Hpjmeter, the Java-based performance/profiling analysis client for HPE NonStop systems, can crash the tool when it parses crafted input. Impact is confined to availability (CVSS 3.1 base score 2.0 on the vendor's published vector, assessed as A:L with no confidentiality or integrity effect), and exploitation is gated by high attack complexity and the requirement that a privileged, authenticated user open or process the malicious data - no public exploit has been identified at time of analysis. The published vector nominally claims AV:N, but the behavior described (data/file parsing by a client tool) suggests a local delivery path; this discrepancy is unconfirmed and should be validated against HPE advisory hpesbns05148en_us.
An off-by-one stack out-of-bounds write in Mini-XML 4.0.0 through 4.0.6 lets an attacker who can supply crafted XML corrupt or crash a parsing application, but only when the host process runs under a locale whose decimal separator is not '.'. Supplying a REAL value of exactly 63 digits immediately followed by '.' drives mxml_strtod()'s decimal-point substitution logic to write a NUL byte one position past its 64-byte stack buffer (CWE-193), corrupting adjacent stack memory. No public exploit identified at time of analysis; independent assessment rates this CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:L (CVSS 4.0 base score 2.0), so all available signals point to a low real-world priority.
Palo Alto Networks PAN-OS can be driven into a denial-of-service condition by an authenticated user holding the read-only administrator role, who triggers the fault by sending a specially crafted API request to the management web interface. Only PAN-OS is affected; Cloud NGFW, Panorama, and Prisma Access are explicitly stated by the vendor to be unaffected. The impact is availability-only and low severity (vendor CVSS 4.0 score 1.2; independent assessment CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:L), and the DoS is automatically recoverable, meaning the device returns to service without manual intervention. No public exploit code has been identified at time of analysis, and the vulnerability is not in CISA KEV.
Stored cross-site scripting in the Palo Alto Networks PAN-OS management web interface allows an authenticated administrator with high privileges to persist a JavaScript payload that executes when another administrator views the affected page. This is a low-severity issue (vendor CVSS 1.1; independent assessment CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:U/C:L/I:L/A:N), requiring a second admin's interaction and affecting PAN-OS on PA-Series and VM-Series firewalls and Panorama (virtual and M-Series); Cloud NGFW and Prisma Access are not affected. Vendor patches are available, and no public exploit was identified at time of analysis.
Server-side request forgery in Palo Alto Networks Checkov by Prisma Cloud before version 3.2.533 allows a local unauthenticated attacker to induce the tool to make unauthorized network requests from the host to internal services. The attacker must influence Infrastructure-as-Code content parsed by Checkov, and a victim must run a scan on a host with network reachability to the target services; it is not remotely triggerable. No public exploit code has been identified, and the impact is limited to low-severity SSRF without confidentiality or integrity impact on the Checkov host itself, though other systems may experience low confidentiality impact. A vendor patch is available in version 3.2.533.
Credential leakage in curl 8.21.0 through 8.22.0 allows unauthenticated remote attackers to obtain Negotiate (SPNEGO/Kerberos) authentication tokens when a redirect or cross-origin transition causes the 'Authorization: Negotiate' header to be sent to a foreign origin. The flaw is rated LOW by the curl project and has an assessed CVSS 3.1 score of AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N; no public exploit code was identified at time of analysis. Exploitation requires the user to explicitly enable Negotiate authentication (e.g., via --negotiate or CURLAUTH_NEGOTIATE) and for the request flow to reach a foreign origin, limiting impact to token disclosure rather than code execution or service disruption.
Negotiate (Kerberos/SPNEGO) credentials are forwarded to the wrong origin by curl and libcurl 8.21.0 through 8.22.0 when the initially contacted server returns an HTTP redirect to a different host while redirect following is enabled. An attacker who controls or influences either the redirect response or the redirect destination can capture the Negotiate authentication token, resulting in limited confidentiality exposure rather than code execution or data modification. The flaw is rated LOW by the curl project, no public exploit code has been identified at time of analysis, and it was fixed in the curl 8.23.0 release published on 2026-10-14 alongside twenty-three other advisories.
A never-ending loop condition in curl and libcurl 8.10.0 through 8.22.0 lets a malicious, compromised, or on-path-manipulated server hang the client by omitting an expected part of its response, producing availability-only impact (the affected transfer or process spins indefinitely) with no confidentiality or integrity effect. The curl project rates this flaw LOW severity, and it is one of twenty-four CVEs disclosed alongside the curl 8.23.0 release. Exploitation requires the victim to connect outbound to the attacker's endpoint, since curl is a client and cannot be attacked purely remotely against a listening service; the exploit is not confirmed as actively exploited (not in CISA KEV), no public exploit code has been identified at time of analysis, and no EPSS score was provided in the source data.
Credential disclosure in curl and libcurl at or below 8.22.0 causes origin host credentials to be sent to a configured HTTP proxy instead of being reserved for the intended origin server. The flaw only manifests when a deployment both routes transfers through an HTTP proxy and supplies credentials intended for the origin host, which is why the curl project rates it LOW severity and why the independent assessment scores it CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N - confidentiality-only impact with high attack complexity and no integrity or availability effect. There is no KEV listing and no public exploit identified at time of analysis, so real-world urgency is driven mainly by whether an environment uses untrusted or shared proxies alongside origin credentials. The fix ships in curl 8.23.0.
Persisted HSTS entries held by curl and libcurl can be erased when a malicious or on-path server returns a crafted Strict-Transport-Security response, allowing an attacker to strip previously stored HTTPS-only policy for other hosts. Only builds running up to and including 8.22.0 that have HSTS persistence explicitly enabled (the curl tool's --hsts <file> option, or libcurl with CURLOPT_HSTS pointed at a cache file) are exposed - this is not a default configuration, which is the main limiting factor. The assessed impact is integrity-only (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N), with no code execution or direct data disclosure; harm is indirect and deferred, since a later connection to a de-pinned host is only downgradable if the attacker can also intercept that subsequent traffic. No public exploit code has been identified at time of analysis and there is no indication of active exploitation. Fixes ship in curl 8.23.0, which resolves this issue alongside twenty-three other CVEs published on the same date.
A crafted Set-Cookie header returned by a server can abort the loading of curl/libcurl's cookie jar in versions 8.7.0 through 8.22.0, disrupting the client's cookie-persistence routine instead of completing the jar load. The flaw is only reachable when the client is configured to use a persistent cookie jar (the -b/--cookie or -c/--cookie-jar options, or CURLOPT_COOKIEFILE/CURLOPT_COOKIEJAR in libcurl) and the attacker controls or has compromised the server end of the connection, so it is a network-reachable but low-impact integrity issue (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N). The curl project rates this LOW severity as part of its 8.23.0 release, no public exploit code or confirmed active exploitation has been identified at time of analysis, and no EPSS or KEV signal is associated with the CVE.
Persisted HSTS state in curl/libcurl can be silently truncated when a previously exported HSTS cache is re-imported, because the import logic drops a longer-lived child entry (for example an includeSubDomains rule) in favor of a shorter-lived parent. Applications that explicitly enable curl's HSTS support via CURLOPT_HSTS or the --hsts option and persist that cache to disk across runs are affected; default curl usage with HSTS off is not. The resulting loss of HSTS enforcement only becomes exploitable if an on-path (man-in-the-middle) attacker is positioned to force a protocol downgrade to plaintext HTTP, so the curl project rates this severity LOW and no public exploit code or KEV/EPSS signal is present in the available data. Remote attackers, no authentication required per the assessed vector (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N), but attack complexity is high and confidentiality/integrity impact is limited.
Cross-origin reuse of a Negotiate-authenticated connection in curl and libcurl (through 8.22.0) allows a connection authenticated to one origin to be reused for a request to a different origin when a single easy handle or connection cache serves multiple hosts. The curl project rates the issue LOW, and the assessed vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N shows no privileges required (PR:N) but a high attack complexity, with only a low-confidentiality impact and no integrity or availability effect - there is no memory corruption or code-execution component. Exploitation is conditional on the consuming application being built with Negotiate/SPNEGO (GSSAPI/Kerberos) support and deliberately reusing connections across more than one origin, so it is not a remotely triggerable flaw against a default curl configuration; no public exploit code or CISA KEV entry is identified at time of analysis, and no EPSS score was provided in the available data.
A server-controlled response can erase the contents of a libcurl application's persisted cookie jar in curl/libcurl 8.18.0 through 8.22.0, allowing a malicious, compromised, or impersonated HTTP server to destroy stored cookie state. The flaw only triggers when the application has the cookie engine enabled together with cookie-jar file persistence (the curl tool's -c/--cookie-jar option or the CURLOPT_COOKIEJAR libcurl option); without that configuration the code path is unreachable. Impact is bounded to loss of stored cookie data - an integrity-only concern with no code execution, no credential disclosure, and no further system compromise - and no public exploit code was identified at time of analysis, which is consistent with the LOW severity assigned by the curl project and the AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N assessment.
Stack exhaustion in libcurl's MIME handling can crash applications that construct deeply nested multipart structures: curl_mime_free() recurses once per nesting level, so a sufficiently deep curl_mime_subparts() hierarchy overflows the stack and aborts the process. Affected are libcurl/curl versions 7.56.0 through 8.22.0, fixed in 8.23.0; the curl project classifies this advisory as LOW severity, with the impact limited to denial of service (no code execution, no data disclosure). The assessed vector (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) reflects that exploitation is confined to libcurl-based applications that let untrusted input dictate MIME nesting depth, and there is no public exploit identified at time of analysis.
SSH host-key verification that the user explicitly requested is silently dropped by the curl command-line tool when an SFTP or SCP transfer is reached by following an HTTPS redirect, so `--knownhosts`, `--hostpubsha256`, and `--hostpubmd5` never take effect on that connection. Only the opt-in combination of `--location` plus `--proto-redir +sftp` starting from an HTTPS URL is affected, and an attacker must additionally control the HTTPS response (to inject `Location: sftp://...`) and hold an in-path position to impersonate the SSH host - the bug degrades a requested security control rather than providing code execution or data access by itself. The independent assessment scores this CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:N (Medium severity, unauthenticated but requiring user interaction), and no public exploit identified at time of analysis.
An out-of-bounds read in curl when built with the GnuTLS TLS backend and WebSocket support allows a malicious WebSocket server to cause the client to send memory beyond its send buffer, potentially disclosing limited process memory (C:L) and causing a low availability impact (A:L). This unauthenticated attack (PR:N) requires user interaction (UI:R) because the victim must connect to an attacker-controlled WebSocket server; affected builds are those using GnuTLS rather than OpenSSL and with WebSocket support enabled, which is experimental and off by default in many distributions. No public exploit code or CISA KEV listing was identified at time of analysis, and no CVSS, EPSS, or POC data was provided, so quantitative exploitation signals are absent; a vendor patch is available per the Ubuntu security notice USN-8927-1.
In the Linux kernel, the following vulnerability has been resolved: ksmbd: follow SMB2 session expiration semantics ksmbd_session_register() destroys valid sessions after ten seconds of inactivity whenever a client starts another SessionSetup exchange. This confuses Session.IdleTime with Session.ExpirationTime. Windows can create additional authenticated sessions on an existing connection, so deleting the older session invalidates its tree connects and makes mapped drives fail with STATUS_NETWORK_NAME_DELETED. The session expiration rules require the server to change a valid session to expired only after its credential expiration time passes. A valid or expired session otherwise keeps its connection from being scavenged. Connections that have not negotiated a dialect, have no sessions, or have only InProgress sessions are disconnected after an implementation-specific timeout. Use the Windows-compatible 45 second value and run the expiration check periodically for both TCP and SMB Direct. Keep zero as an infinite credential expiration time, and count each Valid-to-Expired transition. Set expired sessions to InProgress when they reauthenticate. If authentication fails, remove the session from the global and per-connection tables immediately, including SMB3 multichannel connections. Retain protection against abandoned SessionId-zero exchanges by allowing only one InProgress authentication per connection. Additional exchanges fail with STATUS_INSUFFICIENT_RESOURCES, and stale InProgress sessions are reaped after the same 45 second setup timeout. This bounds the original unauthenticated memory-exhaustion path without evicting established sessions.
In the Linux kernel, the following vulnerability has been resolved: wifi: mwifiex: fix IRQ leak using wrong index in MSI-X error path mwifiex_pcie_request_irq() registers each MSI-X vector with a per-index dev_id (&card->msix_ctx[i]). On a request_irq() failure the cleanup loop "for (j = 0; j < i; j++)" frees msix_entries[j].vector but passes the failed index's &card->msix_ctx[i] as the dev_id. free_irq() matches on (irq, dev_id), so it fails to find the action registered with &card->msix_ctx[j]: the already-requested IRQ j is not freed (leaked) and free_irq() warns about freeing a non-existent IRQ. Use &card->msix_ctx[j].
In the Linux kernel, the following vulnerability has been resolved: wifi: mac80211: reset the AP_VLAN tailroom counter on ifdown On ifup, AP_VLAN interfaces get crypto_tx_tailroom_needed_cnt from the AP interface, but it's never decremented again unless the AP is also brought down. Thus, bringing the same AP_VLAN up again will increment the counter again and eventually hit the sanity check: WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt != master->crypto_tx_tailroom_needed_cnt); Reset it on ifdown to avoid that.
In the Linux kernel, the following vulnerability has been resolved: selinux: always fill AVC decision in avc_has_perm_noaudit() avc_has_perm_noaudit() is documented to return a copy of the access decision in @avd, but its early return for an empty requested permission set leaves the buffer untouched. All callers pass an uninitialized stack variable and afterwards feed it to avc_audit(), and the inode hook even stores it in the per-task decision cache. Fill in a deny-all, audit-all decision, similar to avd_init(), so every caller receives a defined value at no cost on the hot path.
In the Linux kernel, the following vulnerability has been resolved: wifi: rsi: fix heap OOB write on key removal When a key is removed (data == NULL), rsi_hal_load_key() runs: memset(&set_key[FRAME_DESC_SZ], 0, frame_len - FRAME_DESC_SZ); set_key is a struct rsi_set_key *, so the subscript is scaled by sizeof(struct rsi_set_key) (160 bytes): &set_key[FRAME_DESC_SZ] is skb->data + 2560, and the memset writes 144 zero bytes starting 2.4KB past the end of the 160-byte skb data buffer, corrupting unrelated heap objects. The intended byte offset would have been (u8 *)set_key + FRAME_DESC_SZ. The write fires on every DISABLE_KEY callback, so plain disconnects, roams and interface teardowns trigger it on real networks. The memset is redundant: the whole buffer is zeroed right after allocation, so the frame sent to the device is byte-identical without it. Drop the else branch; normal operation is unaffected. Discovered by Atuin - Automated Vulnerability Discovery Engine.
In the Linux kernel, the following vulnerability has been resolved: wifi: mac80211: avoid WARN in set_bitrate_mask when sdata not in driver ieee80211_set_bitrate_mask() checks if the interface is running via ieee80211_sdata_running(), but it does not check if the interface is still present in the driver. When sdata is running but IEEE80211_SDATA_IN_DRIVER is not set, the call reaches drv_set_bitrate_mask() in driver-ops.h which hits wlan1: Failed check-sdata-in-driver check, flags: 0x0 WARNING: net/mac80211/driver-ops.h:884 at drv_set_bitrate_mask Syzkaller triggers this via wext SIOCSIWRATE ioctl. The Call Trace shows wext_ioctl_dispatch() in wext-core.c dispatching the ioctl, calling ioctl_standard_call() for SIOCSIWRATE, which calls cfg80211_wext_siwrate() in wext-compat.c. That builds a bitrate mask and calls rdev_set_bitrate_mask() which ends up in ieee80211_set_bitrate_mask() in cfg.c. The interface is marked running via SDATA_STATE_RUNNING but flags is 0, so check_sdata_in_driver() fails. When the interface is being torn down, or when wext ioctl is issued during interface bringup before drv_add_interface() sets IN_DRIVER, the running check passes while IN_DRIVER is clear. Check IEEE80211_SDATA_IN_DRIVER in ieee80211_set_bitrate_mask() before calling the driver, returning -ENETDOWN. This avoids the WARN_ONCE in driver-ops.h and matches other cfg.c operations that bail early when not in driver. This change should be safe because wiphy mutex is held in cfg80211_wext_siwrate() via guard(wiphy), and IN_DRIVER is set/cleared under RTNL and wiphy paths in drv_add_interface() and drv_remove_interface() in driver-ops.c, so the check is race-free against driver add/remove. Returning -ENETDOWN is the same error other not-running paths use and does not introduce new locking. [also add second syzbot report]
In the Linux kernel, the following vulnerability has been resolved: drm/virtio: Fix a NULL vs ERR_PTR() bug in virtio_gpu_user_framebuffer_create() Smatch complains that returning a NULL here will lead to a NULL pointer dereference in drm_mode_addfb2(). Return an error pointer instead.