Red Hat
Monthly
Ghostscript as shipped with Red Hat Enterprise Linux 8-and, per CPE data, RHEL 6, 7, 9, and 10-may allow an attacker to escape -dSAFER protections when it processes a crafted PostScript file, enabling file access outside permitted paths or command execution with the Ghostscript process's privileges. The root cause is that Red Hat's 9.25-to-9.27 rebase omitted the CVE-2019-14869 correction, leaving privileged .forceput operations in the .charkeys procedure insufficiently protected; the supplied CVSS base score is 7.3, while the independent assessment treats confidentiality and integrity impact as High (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L). No CISA KEV entry is present in the supplied data and no public exploit identified at time of analysis; practical risk is conditional on a service or pipeline actually processing untrusted PostScript/EPS with an affected RHEL build.
Red Hat Advanced Cluster Security for Kubernetes (RHACS) Central's SAML assertion consumer service (ACS) endpoint does not cache used assertion or response identifiers, so a single valid signed SAML response can be replayed to mint multiple distinct Central authentication tokens for the same mapped identity. Deployments are only exposed when Central is configured to authenticate via SAML; an attacker must first obtain a legitimately signed, unexpired SAML response - they cannot forge one - which is why the issue is rated CVSS 7.4 with high attack complexity despite requiring no privileges or user interaction. Successful replay yields full compromise of confidentiality and integrity for the impersonated identity; no public exploit code or confirmed active exploitation was identified at time of analysis, and non-SAML authentication configurations are unaffected.
Unbounded resource allocation in ASP.NET Core - reachable through the System.Formats.Cbor component shipped with Microsoft Visual Studio 2022 version 17.14 and Visual Studio 2026 version 18.10 - lets unauthenticated remote attackers exhaust server resources and cause a denial of service. The flaw is rated CVSS 7.5 (AV:N/AC:L/PR:N/UI:N, availability-only impact), meaning any network-exposed service that actually parses attacker-supplied CBOR input through the vulnerable path can be driven into resource exhaustion without credentials or user interaction. Exploitation is bounded by reachability: deployments that never process untrusted external CBOR/network data, or that sit behind request-size limits, rate limiting, timeouts, or a WAF, have materially reduced exposure. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV; a vendor patch is available via the Microsoft Security Response Center advisory.
Process-terminating denial of service in undici, the Node.js HTTP client, affecting versions 7.15.0 through 7.30.0 and 8.0.0 through 8.12.1. When an application composes the decompress interceptor with a downstream response handler that throws during response processing - most notably the built-in dump interceptor hitting its configured maximum response size - a remote server controlled or compromised by an attacker can return a tiny compressed body that expands past that limit, and the resulting throw originates asynchronously inside a zlib stream callback where undici's engine does not convert it into a per-request failure, so it surfaces as an uncaught exception that terminates the Node.js process. The assessed vector (AV:N/AC:L/PR:N/UI:N, availability-only, A:H) makes this an unauthenticated remote crash with low attack complexity, but exposure is bounded because the vulnerable interceptor pairing is not undici's default behaviour and only the listed version ranges are affected. Vendor patches are available in 7.30.1 and 8.12.2, EPSS is low at 0.25% (15th percentile), SSVC records exploitation as none and automatable as no, and no public exploit code was identified at time of analysis.
Denial of service in AdonisJS HTTP Server (adonisjs/http-server) lets unauthenticated remote attackers stall the Node.js event loop: versions prior to 8.2.2 and 9.1.1 contain a catastrophic-backtracking regular expression in router.matchers.slug(), and a long slug ending in a character rejected by the final assertion triggers quadratic CPU consumption. Because the matcher runs during route matching and before route and group middleware, authentication or rate-limiting middleware attached to the affected route does not prevent the request from blocking the worker and starving unrelated requests and health checks. Impact is availability-only with no data exposure, the CVSS 4.0 base score is 8.7 (assessed CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), no public exploit identified at time of analysis, and exploitation requires the application to explicitly apply the slug matcher to an externally reachable, attacker-controlled route parameter rather than affecting every AdonisJS deployment.
Denial of service in the undici HTTP client library for Node.js allows any attacker-controlled or compromised HTTPS endpoint to terminate the client process by performing a TLS 1.2 renegotiation. When a server renegotiates after the connection is established and presents a different CA-trusted certificate whose hostname does not match the requested host, Node.js re-runs hostname verification and destroys the socket with a certificate-altname error; undici's established-socket error handler treated that error code as impossible, so the peer-controlled condition became an uncaught assertion (CWE-248) that crashes Node.js and kills all in-flight requests and background work. The flaw affects undici 4.2.1 through 6.29.0, 7.0.0 through 7.30.0, and 8.0.0 through 8.12.1 on both the HTTP/1.1 and HTTP/2 paths, and is reachable through Node's global fetch() as well as direct library use; it is remotely triggerable without authentication or a CA compromise (CVSS 3.1 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), though only TLS 1.2 connections are exploitable since TLS 1.3 removed renegotiation. No public exploit code was identified at time of analysis and there is no indication of confirmed active exploitation, but exploitation is trivial for any adversary who can serve an endpoint the victim fetches from, and patched releases 6.29.1, 7.30.1, and 8.12.2 are available.
Unauthenticated remote requests can crash Go services that embed kin-openapi before 0.148.0: posting a YAML body containing .nan, .inf, or -.inf to an OpenAPI 3.1 operation carrying a numeric constraint drives the bundled santhosh-tekuri/jsonschema v6.0.2 into a nil big.Rat dereference, panicking inside ValidateRequest. The assessed CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), reflecting availability-only impact: a standard net/http server recovers the panic per connection so the effect is usually a single dropped request, while non-net/http hosts or panics raised in application goroutines can terminate the process. No public exploit code has been identified at time of analysis and there is no evidence of confirmed active exploitation; the need to reach an OAS 3.1 spec, accept application/yaml (or application/x-yaml), and hit an operation with a numeric constraint keeps this a genuine but bounded denial-of-service issue.
Path traversal in wildfly-core's deployment content handler allows an authenticated JBoss EAP, WildFly, Fuse 7, or Single Sign-On 7 user who holds the Deployer RBAC role to escape the restricted deployment directory and create files with attacker-controlled content or delete arbitrary directories on the server, escalating to full management SuperUser privileges. Exploitation requires that the Deployer role be delegated to the attacker (CVSS vector shows PR:L - authenticated, not anonymous) plus a crafted deployment name containing traversal sequences; environments that reserve the Deployer role for fully trusted administrators face little practical exposure. No public exploit code was identified at time of analysis and the flaw is not listed in CISA KEV, so this is a credible, actionable priority rather than an emergency.
An unauthenticated remote request can slip past kin-openapi's openapi3filter authentication middleware and reach a handler that was meant to be protected, when the library's ValidationHandler is used as middleware in front of a gorilla/mux router configured with UseEncodedPath. The library validates the operation it derives from the decoded URL.Path (0.144.0 through 0.146.x), while the downstream mux router, using the raw encoded path, dispatches to a different, protected parameterized route that overlaps the public exact route after decoding - so requests carrying an encoded slash (%2F) can be validated as the public operation and then served by the protected handler without the configured AuthenticationFunc ever running. Reaching the flaw requires a precise deployment stack (kin-openapi >=0.144.0 <0.147.0, ValidationHandler wired as auth middleware, mux with UseEncodedPath, and an overlapping public exact route plus protected parameterized route sharing an HTTP method), which is reflected in the CVSS 7.4 rating with AC:H; no CISA KEV listing, and no public exploit identified at time of analysis, though the upstream fix commit includes a regression test that reproduces the bypass.
A nil-pointer panic in kin-openapi's openapi3filter validation path can crash any Go service that embeds versions 0.136.0 through 0.142.x and serves an OpenAPI 3.1 document with an array schema that omits the items keyword. Unauthenticated remote clients (CVSS vector PR:N/UI:N) only need to send a single nonempty application/x-www-form-urlencoded or multipart/form-data request to an affected operation - or trigger a matching response on a surface such as a response header - to deterministically panic ValidateRequest or ValidateResponse, producing denial of service with no confidentiality or integrity impact (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CVSS 7.5). The risk is real but bounded: only OpenAPI 3.1 specs containing the specific malformed-but-spec-legal array shape are exposed, JSON request bodies use a different decoder, and OpenAPI 3.0 documents are rejected at validation time. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation.
Memory corruption in the Linux kernel IPv4 receive path lets a local attacker who can inject a packet with malformed checksum metadata (an out-of-range skb checksum_start) into the host IPv4 stack cause skb_checksum_help to write into and corrupt the network header, yielding high-integrity and high-confidentiality impact with a changed security scope (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H, 9.3). The flaw is realistically reachable by an unprivileged process inside a sandbox, container, or guest VM that can supply attacker-controlled checksum metadata to the host kernel, making multi-tenant and sandboxed environments the primary exposure; single-tenant systems with no untrusted local or sandboxed workloads are materially less exposed. Exploitation requires local access only (no remote network path indicated), and intelligence available at the time of analysis shows no confirmed active exploitation (no CISA KEV) - though linked references to sandbox-escape research (pwn.ai's 'Pwnescape' and Vercel's $1M sandbox challenge findings) indicate the underlying primitive is being actively studied.
Eclipse Jetty's host whitelist/blacklist enforcement in the jetty-server and jetty-proxy modules performs case-sensitive comparisons, so a remote, unauthenticated attacker can bypass the filter simply by altering the letter case of the Host value (e.g. 'EXAMPLE.com' instead of 'example.com') and reach hosts the operator intended to block or exclude. The flaw only matters where an operator has explicitly configured a host whitelist or blacklist and treats it as a security boundary; deployments without host-based filtering are unaffected. The vendor has published a security advisory (GHSA-7wfj-j486-mxrf), and no public exploit code has been identified at time of analysis, though the low attack complexity (AC:L, PR:N, UI:N) and high confidentiality impact make the bypass straightforward to attempt wherever the non-default filtering configuration is present.
Arbitrary file overwrite in HPE NonStop Python 3.x lets an attacker who supplies a crafted TAR archive escape the intended extraction directory via .. (dot-dot) sequences in member filenames and clobber files on the NonStop host, with the overwritten data potentially leading to code execution or system compromise depending on the privileges of the extracting process. The vendor rates this 8.0 (CVSS:3.1/AV:A/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), while our independent assessment scores it lower at CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:H, treating it as local rather than adjacent-vector and integrity/availability-only; unauthenticated access is implied by PR:N in both vectors, but successful exploitation is not automatic - it requires the victim to extract an attacker-controlled archive (UI:R), and the write primitive is bounded by the privileges of the extracting account. No public exploit code was identified at time of analysis, there is no CISA KEV entry, and no EPSS score was supplied, so real-world risk is moderated by the mandatory user interaction rather than by the headline score.
Eclipse Jetty's HttpClient can disclose proxy authentication credentials to a malicious server when the server returns a 407 Proxy Authentication Required status. This information disclosure (CWE-200) affects applications using Jetty's HttpClient with an authenticated forward proxy and connecting to attacker-controlled destinations. Exploitation requires the attacker to control the destination server and the client to be configured with proxy credentials; no public exploit code has been identified at time of analysis, and the CVSS 4.0 score is 8.2 (High).
Path-normalization weakness in Eclipse Jetty's HttpClient causes credential disclosure: when HttpClient receives a redirect whose target contains a non-normalized traversal segment such as /secure/../evil, Jetty matches the stored Authorization credential against the literal /secure prefix rather than resolving the path to /evil, and then follows the redirect - sending the /secure-scoped Authorization header to an endpoint that should never receive it. Per the provided CVSS vector (PR:N) the attacker is unauthenticated, but exploitation carries high attack complexity (AC:H): the attacker must be able to control or influence the redirect response returned to HttpClient, and must already have a malicious application deployed on the SAME domain as the target so the leaked header lands on an endpoint they control. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Denial of service in Nodemailer 3.0.0 through 10.0.9 allows an attacker-controlled or on-path SMTP server to stall a Node.js application by streaming SMTP continuation lines that never deliver a terminating completion line during the greeting/authentication phase. The vulnerable reply parser in SMTPConnection._onData and isPartialResponse re-evaluates its buffered response on every incoming chunk, so parsing cost grows quadratically with the size of the accumulated reply, blocking the single-threaded event loop and consuming memory before authentication completes. No public exploit code was identified at time of analysis, and exploitation is conditional: the client must be configured to connect to an untrusted or attacker-influenceable SMTP server, or an attacker must be positioned on-path on an interceptable SMTP connection, which is why the assessed vector carries AC:H and AT:P and this is a genuine but conditional availability risk rather than a blanket critical one.
Denial of service in Nodemailer 3.0.0 through 10.0.12 lets a malicious or man-in-the-middle SMTP server stall the Node.js event loop by answering EHLO with a crafted '250-AUTH' line followed by a long whitespace run and a non-matching token, which drives quadratic backtracking in the four AUTH-mechanism detection regexes in SMTPConnection._actionEHLO. No authentication is required from the attacker (PR:N) and the trigger occurs before any authentication step, but the victim application must connect outbound to an attacker-controlled or interceptable SMTP endpoint, so deployments pinned to fixed, trusted, TLS-authenticated mail servers are substantially harder to exploit. Impact is confined to event-loop blocking and availability loss (no confidentiality or integrity effect), and no public exploit code was identified at time of analysis; the vendor fix is Nodemailer 10.0.13.
Server-side request forgery in Renovate before 44.79.0 allows authenticated users with low privileges to direct the shared HTTP client at arbitrary internal URLs through 'extends' preset references or 'customDatasources' entries. An attacker who can influence Renovate's configuration - for example by committing to a scanned repository or controlling a preset source - can reach an instance metadata endpoint such as AWS IMDS to obtain credentials, or exfiltrate sensitive information into Renovate logs; real-world impact depends on the deployment's network reachability of internal services. The vendor fixed the issue in Renovate 44.79.0, and no public exploit code has been identified at time of analysis.
Renovate before 44.60.1 permits authenticated repository users with configuration influence to circumvent the allowedHeaders restriction by embedding hostRules[].headers inside shared presets, causing custom HTTP headers to be injected into outbound requests Renovate makes to other hosts. This is an allowlist/authorization bypass requiring low privileges (PR:L per CVSS) and specific, condition-dependent prerequisites (AC:H), making it an insider or supply-chain-style abuse rather than anonymous remote exploitation. It is not confirmed as actively exploited (no CISA KEV entry) and no public exploit code has been identified at time of analysis.
Arbitrary file read in GitPython before 3.2.0 occurs when a vulnerable application clones an attacker-controlled repository and then calls Head.checkout() on the repository's default branch; a branch named like --pathspec-from-file=<path> is parsed by Git as an option rather than a branch, causing readable file contents to be leaked through GitCommandError messages. This is a credible but conditional information-disclosure flaw, not a drop-everything emergency: only confidentiality is affected, exploitation requires the target to process untrusted repositories and surface error output, and no public exploit identified at time of analysis. Unauthenticated network exploitation is possible per the PR:N vector, and the vendor patch is GitPython 3.2.0.
Remote code execution in GitPython releases before 3.2.0 (CVE-2026-110857) allows unauthenticated attackers to execute arbitrary commands through Git.ls_remote, which forwards a caller-supplied remote URL without the check_unsafe_protocols validation that normally blocks dangerous transports, notably ext:: remote-helper URLs when Git's protocol.ext.allow setting permits them. Exploitation is conditional rather than trivial: a consuming application must pass an attacker-controlled URL into the affected API (user interaction is required per the assessed CVSS:3.1 vector AV:N/AC:H/PR:N/UI:R), and a default Git configuration that rejects the ext transport blocks the primary ls_remote path, while the related merge_base and IndexFile.move option-injection paths remain similarly unguarded. No public exploit identified at time of analysis; the flaw is fixed in GitPython 3.2.0.
Information disclosure in GitPython before 3.2.0 lets attackers leak environment-variable secrets through crafted submodule names in a repository's .gitmodules file. The flaw occurs when Repo._clone() calls Git.polish_url() without expand_vars=False, so variable syntax in a submodule name is expanded during clone plus submodule_update and the resulting values surface in .git/modules directory names and DEBUG logs. Exploitation is unauthenticated per the CVSS vector (PR:N) but requires the victim to clone an attacker-supplied repository and invoke submodule handling, and leakage only materializes if sensitive values are present in the process environment; no public exploit code, CISA KEV entry, or EPSS score was identified in the provided data, and integrity and availability are unaffected (CVSS 4.0 base 7.1, moderate severity).
Memory corruption in FreeRDP's grayscale JPEG clipboard conversion can crash the RDP client when a malicious server delivers a crafted clipboard item that the victim pastes as CF_DIB bitmap data. The flaw is a heap-based out-of-bounds write in winpr_convert_from_jpeg, affecting versions 3.3.0 up to but not including 3.32.0 that are built with the non-default WINPR_UTILS_IMAGE_JPEG=ON option. Exploitation requires the victim to connect to an attacker-controlled RDP server with clipboard redirection active and to actively paste the malicious grayscale JPEG; no public exploit code has been identified at time of analysis, and the impact is primarily availability-focused (crash) with limited integrity impact.
Unauthenticated keyboard injection in the FreeRDP shadow server (versions 3.0.0 through 3.31.x) allows remote attackers to send synthetic keystrokes into a host user's X11 session via XTEST by delivering an input PDU during the Confirm Active state, before any authentication takes place. Exploitation requires the shadow/mirroring server to be network-reachable and the host to be running an X11 session over a TLS-only RDP negotiation; the confirmed impact is integrity-only (fabricated input) with no confidentiality or availability effect. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV.
Null pointer dereference in FreeRDP versions 2.0.0 through 3.31.x allows a malicious RDP server to crash Linux clients that have serial-port redirection enabled. The attacker sends IRP_MJ_READ or IRP_MJ_WRITE requests either before the serial channel is created or after it is closed, causing CommReadFile or CommWriteFile to dereference a null handle and terminate the client. This is an availability-only issue (CVSS 4.0 score 7.1, no confidentiality or integrity impact) that requires the victim to initiate a connection to the attacker-controlled server and have serial redirection active; no public exploit code has been identified at time of analysis.
Unbounded heap accumulation in the FreeRDP proxy (the pf/proxy relay component) lets unauthenticated remote attackers exhaust proxy memory by streaming RDPDR device-redirection fragments that begin with a FIRST fragment but never carry a LAST fragment, so reassembly state grows in proportion to bytes sent. Affected deployments are FreeRDP 3.0.0-beta1 through versions before 3.32.0 that run the proxy with the RDPDR channel reachable from untrusted clients; plain FreeRDP client or server deployments are not the stated target. Rated CVSS 4.0 8.2 (High), with assessed CVSS 3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, this is a slow-burn memory-exhaustion DoS requiring sustained fragment traffic rather than a single packet, and there is no public exploit identified at time of analysis.
Authenticated RDP clients can force unbounded server-side memory allocation in FreeRDP 2.0.0 through 3.31.x by sending a seven-byte DATA_FIRST message on an already-opened dynamic virtual channel (DVC) that declares a large 32-bit length, driving zeroed resident-memory growth until the server's resources are exhausted and service is denied. The flaw is availability-only (CWE-400 resource exhaustion; CVSS 4.0 base 7.1, assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) with no code execution or data disclosure impact, and every action requires a valid authenticated session plus a successfully opened DVC - so real exposure depends on who can authenticate to the RDP service, and it is not remotely exploitable without credentials. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Client termination in FreeRDP before 3.32.0 occurs when a malicious RDP server sends repeated serial IRP_MJ_CREATE requests, causing the client to accumulate file descriptors until it hits the CommReadFile FD_SETSIZE assertion and crashes. The flaw requires the non-default serial/COM port redirection channel to be active and the victim to connect to an attacker-controlled or compromised server; it is an unauthenticated remote denial of service with no code execution or data exposure. No public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Null pointer dereference in the FreeRDP client's rdpsnd (audio redirection) channel allows a malicious or compromised RDP server to crash any connecting client running FreeRDP 3.0.0 through 3.31.x, producing a denial of service that terminates the user's RDP session. The trigger is a malformed rdpsnd fragment that sets CHANNEL_FLAG_LAST without CHANNEL_FLAG_FIRST and arrives on a fresh channel; the CVSS vectors (4.0 AV:N/AC:L/AT:N/PR:N/UI:P/VA:H, and the assessed 3.1 equivalent AV:N/AC:L/PR:N/UI:R/A:H) confirm unauthenticated remote reach but strictly availability-only impact - no confidentiality, integrity, or code-execution effect. Exploitation requires the victim to initiate a session against the attacker's server and to have audio redirection negotiated; there is no evidence of in-the-wild exploitation and no public exploit identified at time of analysis.
Guest-to-host out-of-bounds access in DPDK's vhost-crypto backend lets a low-privileged guest VM that is already attached to a vhost-crypto device corrupt host-side memory by racing the host's two reads of an indirect-descriptor next index, a classic TOCTOU double-fetch (CWE-367). Only hosts running DPDK with lib/vhost's vhost-crypto library enabled and actually processing indirect descriptors are exposed, and the race makes reliable exploitation non-trivial - the assessed vector is AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H, reflecting host-local reach via the guest with cross-boundary (guest-to-host) scope change. Red Hat tracks this for Fast Datapath packages on Red Hat Enterprise Linux 8, 9 and 10; no public exploit code has been identified at time of analysis and there is no CISA KEV entry. Realistic exposure is limited to multi-tenant, untrusted-guest or confidential-computing style deployments where the vhost-crypto feature is deliberately enabled.
A use-after-unmap in DPDK's vhost library gives a local attacker who controls a VDUSE (vDPA Device in USErspace) backend, or a guest able to drive IOTLB invalidations on the vhost device, a path to memory corruption inside the host vhost process. The flaw is that the VDUSE handler does not invalidate cached vring pointers when the IOTLB is invalidated, so the code keeps dereferencing vring addresses that have already been unmapped - a classic CWE-416 use-after-free. The assessed CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, base 8.8) marks this as locally reachable, low-complexity and low-privilege, with a scope change (S:C) reflecting that a confined guest/userspace VDUSE device can compromise the host vhost trust boundary; impact is full confidentiality, integrity and availability loss. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so risk is concentrated in multi-tenant virtualization and NFV hosts that specifically enable DPDK VDUSE. Affected packages are Red Hat's Fast Datapath DPDK channel for RHEL 8, 9 and 10, with downstream exposure noted for RHEL, OpenShift Container Platform 4 and OpenStack Platform 13 Queens.
Authentication bypass in PgBouncer 1.17.0 through 1.26.0 allows an authenticated attacker who knows a valid password for at least one user in auth_file to impersonate another user that authenticates via SCRAM, including PgBouncer admin users and backend superusers, by sending a second StartupMessage during the SCRAM exchange against a non-existent database. The issue is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and stems from improper authentication (CWE-287). No public exploit identified at time of analysis, and the flaw does not grant access to users not authenticating via SCRAM.
Denial of service in the Erlang OTP ssl application allows a malicious or man-in-the-middle TLS 1.3 server to crash the node-global session-ticket store on a connecting client, and repeated crashes can exhaust the ssl supervisor restart intensity and take down TLS for every connection on that node. The victim must be a TLS 1.3 client running OTP 23.3 through the fixed releases with session_tickets set to auto (automatic ticket storage and resumption); the crash does not occur when the bogus ticket is received but on the next automatic resumption attempt, and it requires the client to initiate the outbound connection, which is reflected in the assessed AT:P attack-requirement metric and a CVSS 3.1 base of 5.9 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) despite the vendor's CVSS 4.0 score of 8.2. No public exploit code has been identified at time of analysis and there is no CISA KEV listing, but vendor patches and upstream commits are available. Reported by the Erlang Ecosystem Foundation (EEF) and tracked as EUVD-2026-101384.
A crafted DOS (MBR) extended-partition image can trigger a 32-bit integer overflow in util-linux's libblkid partition parser before version 2.41.4, causing the library to report a bogus partition that overlaps the master boot record. An unprivileged local attacker only needs to get a malicious disk image or removable medium in front of a probing path - such as automatic udev/udisks inspection of an inserted USB device, or any tool, VM, or forensic pipeline that scans attacker-supplied images - and no public exploit code or confirmed active exploitation has been identified at time of analysis. The realistic impact is limited: libblkid's reported partition metadata is falsified (an integrity issue), while actual disk modification or availability loss would require a separate downstream consumer to trust and act on that incorrect metadata, so the practical risk is modest despite a higher CVSS base score in some feeds.
A double-offset error in DPDK's vhost log-mapping calculation (lib/vhost) lets local attackers with low privileges (PR:L) - including a guest that controls a virtio device serviced by the vulnerable vhost-user backend - trigger incorrect host memory accesses that compromise confidentiality, integrity and availability, giving a 7.8 HIGH rating (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is tracked by Red Hat and ships in Fast Datapath for RHEL 8, 9 and 10, which in turn is consumed by Red Hat Enterprise Linux 8/9/10, OpenShift Container Platform 4 and OpenStack Platform 13 (Queens), so exposure is concentrated in OVS-DPDK accelerated virtualization and NFV hosts that exercise the vhost log-mapping path (for example during guest dirty-page logging/live migration). No public exploit identified at time of analysis, and no CISA KEV listing or exploit code is referenced in the available intelligence.
Heap buffer overflow in DPDK's lib/vhost VDUSE control-queue handler allows a local, low-privileged (authenticated) actor to corrupt heap memory with attacker-controlled content, enabling privilege escalation and loss of host integrity. The root cause is a time-of-check-to-time-of-failure (TOCTOU) double-fetch: the control-queue descriptor is read twice from memory the attacker can modify in between, so the length used for the copy can differ from the length that was validated. Only deployments that actually exercise the VDUSE (vDPA Device in Userspace) control-queue path are exposed, and because winning the race is probabilistic the CVSS base score of 7.8 (AV:L/AC:L/PR:L) is more realistically an AC:H scenario per our assessment; no public exploit code and no confirmed active exploitation were identified at time of analysis. This is a genuine privilege-escalation and host-integrity concern rather than a mass-exploitation threat, since it is strictly local, involves no remote network path, and requires controlling the descriptor memory between fetches.
Local privilege escalation in the SUID-root mount(8) utility shipped with util-linux 2.39.1 through 2.41.4 and 2.42 through 2.42.1, where the attacker-controlled LIBMOUNT_FORCE_MOUNT2 environment variable is read with getenv() and can force the legacy, non-atomic multi-step bind-mount path. On hosts whose /etc/fstab contains a bind mount authorized for unprivileged use via the user or users option and hardened with nosuid, noexec, or nodev, a local low-privileged user can win a timing race between the initial bind mount and the follow-up remount that applies those protective flags, briefly exposing an unprotected mount from which a SUID binary can be executed to obtain root. Exploitation is conditional (it requires that specific non-default fstab configuration) and non-deterministic because it depends on a race window; no public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV). Vendor-released patches are available in util-linux 2.41.5 and 2.42.2.
Buffer overflow in the DPDK vhost-user backend's split-ring inflight descriptor table handling allows a guest VM with code execution to corrupt host memory, potentially leading to code execution on the host. This high-severity flaw (CVSS 8.8) is the most critical issue in a bundled DPDK security advisory and affects multi-tenant deployments where the split-ring inflight feature-used for vhost-user reconnection and live migration-is enabled. No public exploit code has been identified at the time of analysis.
Local privilege escalation to root in util-linux's libmount affects versions 2.17 through 2.41.6 and 2.42 through 2.42.3, and also 2.42.4 when the legacy mount(2) path is used without /proc available. A local, low-privileged user who is already authorized by an /etc/fstab entry carrying the user or users option can exploit a time-of-check/time-of-use race: libmount validates the fstab target path and then the mount operation re-resolves that pathname, so an attacker who controls a writable ancestor directory can use renameat2(RENAME_EXCHANGE) to swap a path component and redirect the authorized mount to a root-owned location such as /etc/sudoers.d, gaining root. Exploitation is local only, requires the attacker to already hold an fstab mount authorization plus a writable ancestor on the configured target, and depends on winning the race (assessed AC:H), so it is non-deterministic; patched code paths using the new mount API (2.41.5 / 2.42.2 and later) or 2.42.4 with /proc present are not affected, and no public exploit identified at time of analysis.
Local privilege escalation in util-linux's SUID mount utility affects versions 2.39 through 2.41.4 and 2.42 through 2.42.1: a local, already-authorized low-privileged user can win a narrow timing race in the post-mount hook and redirect a privileged chmod()/lchown() onto a root-owned path, potentially obtaining root privileges. Exploitation requires a non-default /etc/fstab entry that combines the 'user' or 'users' mount option with an X-mount.mode, X-mount.owner, or X-mount.group option, plus write access to a writable ancestor directory of the mount target; the race itself is difficult (CVSS 3.1 7.0, AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H). No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has released fixes in 2.41.5 and 2.42.2.
Unauthenticated remote attackers can trigger a use-after-free in NGINX's ngx_http_core_module when asynchronous file I/O (AIO) is enabled and a Server Side Includes (SSI) page containing 'include virtual' commands is processed, causing memory corruption or a worker process crash. This affects both NGINX Plus and NGINX Open Source, with code execution possible only on systems where Address Space Layout Randomization (ASLR) is disabled or can be bypassed. Exploitation requires a non-default configuration (AIO and SSI enabled), and no public exploit code was identified at time of analysis.
Heap buffer overflow in NGINX Plus and NGINX Open Source can be triggered by crafted HTTP requests when a non-default map directive with regex matching is configured so that the root directive or access log format references the map's regex capture variables before the map output variable, or when a non-cacheable variable is used in a string expression under specific conditions. The flaw is remotely reachable without authentication (CVSS PR:N) but has high attack complexity (AC:H) because exploitation depends on conditions beyond the attacker's control and on a non-default configuration; the realistic outcome on systems with ASLR enabled is worker-process restart/DoS, while code execution is limited to systems with ASLR disabled or bypassed. F5 rates this CVSS 4.0 9.2 (Critical), and no public exploit identified at time of analysis.
SSL session ticket key handling in NGINX Plus and NGINX Open Source can let a remote unauthenticated attacker forge client SSL sessions and bypass client certificate verification, but only on instances that enforce mutual TLS and rely on NGINX's automatic ticket key rotation. Exploitation is conditional and non-deterministic: the affected deployments must be configured with ssl_session_cache shared:name:size and must not set an explicit ssl_session_ticket_key file, and the resulting forgery is beyond the attacker's control (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N, 6.5). There is confirmed data-plane information exposure potential but no control-plane exposure, and no public exploit identified at time of analysis.
Heap buffer overflow in NGINX Plus and NGINX Open Source can be triggered by unauthenticated remote attackers through crafted HTTP requests, but only when a non-default configuration uses the alias directive together with rewrite and a set or return directive referencing the $request_filename variable, or when $request_filename is used in an access log format directive. Successful exploitation causes a heap buffer overflow in the NGINX worker process, leading to a restart (denial of service) and potentially allowing code execution on systems with ASLR disabled or bypassable. No public exploit code or active exploitation has been identified at time of analysis.
OS command injection in xhtml2pdf before 0.2.19 lets an attacker execute arbitrary OS commands as the invoking user when the pisa command-line tool is run with the -s/--start-viewer option against a file whose name contains a double quote plus shell metacharacters. The flaw lives in pisa.startViewer(), which interpolates an unescaped filename into os.system('open "%s"'); because the vulnerable path is only reached in viewer-launch mode, the default programmatic HTML-to-PDF conversion API is not affected. The vector is local and requires a user (or job) to actually launch the viewer, and no public exploit code has been identified at time of analysis - confirmed actively exploited status is not present in the available data.
Path-restriction bypass in BusyBox httpd's reverse proxy feature allows unauthenticated remote attackers to reach backend paths outside the configured forwarding prefix. When URL-prefix proxying is configured, only the first request on a TCP connection has its path rewritten; a pipelined second request is relayed verbatim, defeating the intended prefix restriction and exposing arbitrary backend routes. Affects BusyBox httpd deployments, including Red Hat Hardened Images, that enable the non-default reverse proxy directive; no public exploit identified at time of analysis. CVSS 3.1 base score 7.2 (High) reflects network reachability, low complexity, no privileges or user interaction, and changed scope impacting the proxied backend.
Arbitrary file write outside the intended extraction directory is possible in BusyBox's dpkg-deb applet because its ar archive handler flushes deferred symlinks after every archive member rather than once after the final member. A crafted .deb containing two data.tar members - the first declaring a symlink to an absolute path such as '/', the second declaring a regular file whose path traverses that now-live link - causes a file to be written at an attacker-chosen location when the package is unpacked (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-59). Affected systems are BusyBox builds compiled with dpkg-deb support, including BusyBox shipped inside Red Hat Hardened Images; the CVSS vector indicates no privileges are required by the attacker (PR:N) but the victim must interact by extracting the untrusted package, and the vector's local attack value plus the non-trivial two-member structure keep this a context-dependent integrity issue rather than a mass-exploitation emergency. No public exploit identified at time of analysis.
Heap-based buffer overflow in GStreamer's gst-plugins-base plugin library lets a local attacker who controls the sending side of a GStreamer inter-process IPC pipeline corrupt memory in the receiving process, yielding a CVSS 3.1 base score of 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) with high confidentiality, integrity, and availability impact. The victim process maps a crafted video buffer whose GstVideoMeta declares plane strides and offsets larger than the actual backing allocation, causing out-of-bounds reads and writes that can crash the process or potentially permit code execution in its context. Exploitation is strictly local and requires a deployment where GStreamer buffers cross a trust boundary between a less-trusted producer and a more-trusted consumer; no user interaction or authentication to the victim is needed, and no public exploit has been identified at time of analysis.
Use-after-free in curl's HTTP/2 client code (curl 8.12.0 through 8.22.0) can corrupt memory when a server answers an in-progress upload with an HTTP/2 RST_STREAM frame carrying the HTTP_1_1_REQUIRED or REFUSED_STREAM reason code, freeing the internal struct Curl_easy object while it is still referenced by the transfer state machine. The flaw is remote and requires no authentication (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, base 8.1), but exploitation is conditional: the victim must be uploading over a negotiated HTTP/2 connection to an endpoint the attacker controls or influences, and the RST_STREAM must land at the right point in the transfer lifecycle, which is why the assessed complexity is High. Publicly available exploit code exists (SSVC Exploitation: poc) and CISA's framework rates technical impact as total, yet there is no confirmed active exploitation (not in CISA KEV) and EPSS is low at 0.23% (12th percentile); a vendor patch is available. The same flaw affects libcurl and therefore every downstream application and distribution shipping an affected build.
Privilege escalation in the Ignition Perspective module (Inductive Automation Ignition) - a genuine high-priority issue in an OT/ICS context - allows an authenticated user with legitimate access to a Vision project to supply their valid Vision session identifier and obtain Designer-level privileges, leading to arbitrary code execution in the context of the Ignition Gateway process. The flaw (CWE-863, CVSS 8.7) affects Gateways where both Vision and Perspective modules are deployed, requires low-privilege Vision credentials and a valid session, and needs network reachability but no user interaction. No public exploit identified at time of analysis.
A use-after-free in Google Chrome's Media component lets a remote, unauthenticated attacker trigger memory corruption and execute arbitrary code inside the browser's renderer sandbox when a victim loads a crafted HTML page in any Chrome build prior to 155.0.8059.79. Exploitation is not confirmed in the wild - CISA's SSVC assessment lists exploitation as none and no public exploit code has been identified at time of analysis - and the EPSS score is low at 0.21% (10th percentile), although the technical impact if successfully triggered is total. User interaction is mandatory (UI:R), the attacker needs no credentials or privileges (PR:N), and Google has released a fixed build, so risk is serious but not emergency-grade.
Use-after-free in Google Chrome's Media component (versions prior to 155.0.8059.79) allows a remote, unauthenticated attacker to corrupt memory and execute arbitrary code inside the browser's renderer sandbox when a victim opens a crafted HTML page containing malicious media content (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, Chromium severity High). Successful exploitation requires only that the user navigate to the attacker-controlled page with an affected build; no credentials or non-default configuration are needed, so default desktop installations are exposed. No public exploit code has been identified at time of analysis, and CISA's SSVC assessment records exploitation as "none" with automatable "no," so this is a patch-promptly issue rather than an active emergency. Real-world impact is bounded by the fact that code execution stays within the sandboxed renderer process (scope unchanged, S:U); an attacker would need to chain a separate sandbox-escape flaw to reach the host operating system.
In-sandbox remote code execution is possible in Google Chrome builds prior to 155.0.8059.79 because of a use-after-free in the V8 JavaScript engine that is triggered when a victim loads a crafted HTML page. The issue carries a CVSS v3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and Google rates it High severity; no authentication or non-default configuration is required, but the attacker must induce a user to open the malicious page, and successful exploitation is confined to the browser sandbox, so full host compromise would also require a separate sandbox-escape flaw. No public exploit code and no active exploitation have been identified at time of analysis, and CISA's SSVC decision framework records Exploitation: none and Automatable: no, although the SSVC Technical Impact is rated total. A vendor patch (155.0.8059.79) is available.
Use-after-free in Chrome's V8 JavaScript engine allows remote, unauthenticated attackers to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page in Google Chrome builds prior to 155.0.8059.79. Exploitation is gated by user interaction (the victim must navigate to attacker-controlled HTML/JavaScript), and according to the CISA SSVC evaluation it is neither currently exploited nor assessed as automatable, with no public exploit identified at time of analysis. The SSVC technical impact is rated total within the affected component, but code execution is confined to the renderer sandbox - reaching the host operating system would require chaining a separate sandbox-escape vulnerability.
Arbitrary code execution inside the Chrome renderer sandbox is achievable through a use-after-free in the browser's Media component, affecting all desktop Chrome builds prior to 155.0.8059.79. An unauthenticated remote attacker can trigger the flaw by getting a victim to load a crafted HTML page; the CVSS vector requires user interaction (UI:R), so there is no zero-click path, and no public exploit has been identified at time of analysis. Impact is scoped to the renderer (S:U), meaning a successful exploit yields code execution within the sandbox rather than host compromise unless chained with a separate sandbox escape; Google classifies the issue as High severity and has shipped a fixed build.
Heap-based buffer overflow in Google Chrome's Animation component allows a remote attacker to execute arbitrary code inside the renderer sandbox by getting a victim to load a crafted HTML page in any build prior to 155.0.8059.79. The bug carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H): no authentication or special configuration is required, but exploitation depends on the user rendering attacker-controlled content, and because the scope is unchanged the resulting code execution is confined to the sandboxed renderer process rather than the host OS. No public exploit code and no confirmed active exploitation have been identified at time of analysis - CISA's SSVC evaluation rates Exploitation as 'none' - so this is a patch-promptly item rather than an emergency, with Google rating the issue High severity.
A use-after-free in the Core component of Google Chrome allows a remote attacker to potentially execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page. Affected builds are those prior to 155.0.8059.79, per the vendor advisory (EUVD's affected-version data lists the same 155.0.8059.79 threshold). Exploitation requires unauthenticated remote delivery with user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6) and is rated Critical by Chromium; there is no confirmed active exploitation (CISA SSVC Exploitation: none) and no public exploit identified at time of analysis, though the SSVC Technical Impact rating of "total" and the scope-changing (S:C) sandbox-escape impact make prompt patching important. Note a platform discrepancy: the description specifies Chrome on Android while the cited vendor reference is a desktop stable-channel update, so the exact affected platform should be confirmed against the advisory.
Use-after-free in the DOM component of Google Chrome prior to 155.0.8059.79 allows unauthenticated remote attackers to potentially execute arbitrary code inside the renderer sandbox by convincing a user to load a crafted HTML page (UI:R). With a CVSS score of 8.8, exploitation yields high confidentiality, integrity, and availability impact within the browser process, though full host compromise would require an additional sandbox escape not covered by this CVE. No public exploit code or active exploitation has been identified at time of analysis, and the vendor has released a patched version.
Use-after-free in Google Chrome's DOM implementation before 155.0.8059.79 allows unauthenticated remote attackers to execute arbitrary code inside the renderer sandbox when a victim navigates to a crafted HTML page. The flaw affects desktop stable and extended-stable channels and carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), with exploitation limited by the requirement for user interaction and by the renderer sandbox preventing direct host compromise without a separate sandbox escape. No public exploit identified at time of analysis, but a vendor patch is available.
Remote code execution confined to the renderer sandbox is possible in Google Chrome Desktop releases prior to 155.0.8059.79, where a use-after-free flaw in the Desktop component is triggered when a victim opens or is redirected to an attacker-controlled crafted HTML page. No authentication or special privileges are required (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 8.8), but exploitation depends on user interaction and the resulting code execution is limited to the sandboxed renderer unless a second, independent sandbox-escape vulnerability is chained. Vendor-released patch: 155.0.8059.79; there is no public exploit identified at time of analysis and CISA SSVC records no known exploitation, so this is a high-priority patch item rather than an emergency.
Use-after-free in Google Chrome's network component allows remote attackers to execute arbitrary code outside the sandbox by delivering crafted network traffic to versions prior to 155.0.8059.79. Exploitation requires a victim to interact with attacker-influenced content (UI:R) but no authentication (PR:N), and the vulnerability carries a CVSS score of 9.6 (Critical). Although no public exploit code or active exploitation has been identified at time of analysis, the severity and potential for full system compromise warrant immediate patching.
Sandbox escape in Google Chrome desktop builds prior to 155.0.8059.79 allows an attacker who can already run a program on the target host to abuse an incorrect authorization check in Chrome's Updater component and execute arbitrary code outside the browser sandbox, with high impact to confidentiality, integrity and availability plus a scope change across the sandbox boundary. The independent assessment scores this CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H, meaning a pre-existing low-privileged local foothold and user interaction are both required, and CISA's SSVC rates the issue non-automatable, so opportunistic mass exploitation is unlikely. No public exploit code or confirmed active exploitation has been identified at time of analysis, and Google has shipped a vendor patch in Chrome 155.0.8059.79.
Sandbox escape through a use-after-free in Google Chrome's Passwords component allows an attacker who has already compromised the renderer process to execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page in versions prior to 155.0.8059.79. The flaw carries a high attack complexity (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, base 8.3) because the heap-timing condition must be reliably won, and it is not a standalone attack: it functions as the second stage of a chain, so no public exploit has been identified at time of analysis and CISA's SSVC assessment rates exploitation as 'none'. Vendor-released patch 155.0.8059.79 is available, which keeps opportunistic mass exploitation unlikely and points to targeted use only.
Use-after-free in SVG rendering in Google Chrome versions prior to 155.0.8059.79 allows a remote, unauthenticated attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page containing malicious SVG content (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-416). Exploitation requires user interaction - the victim must navigate to attacker-controlled content - but no credentials or non-default configuration are needed, so default desktop installations are affected; the resulting code execution is confined to the renderer process, meaning full host compromise would additionally require a separate sandbox-escape bug. No public exploit code has been identified at time of analysis (CISA SSVC exploitation: none), and no public exploit identified at time of analysis; EPSS data was not provided. Google rates the issue Chromium security severity High and has released a stable-channel fix.
Sandbox escape in Google Chrome on macOS lets an attacker who has already compromised the renderer process execute arbitrary code outside the browser sandbox by delivering a crafted extension that abuses incorrect reference resolution in the Extensions subsystem, affecting all Mac builds prior to 155.0.8059.79. Google rates the issue High (Chromium severity: High) and has shipped a vendor fix, and there is no public exploit identified at time of analysis, with the CISA SSVC assessment recording exploitation as none. The impact is total once the chain fires (Scope:Changed, C:H/I:H/A:H), but high attack complexity (AC:H), required user interaction (UI:R) and the hard prerequisite of a prior renderer compromise make this a targeted second-stage escalation rather than a standalone remote exploit.
A heap-based buffer overflow in PDFium, the PDF rendering engine embedded in Google Chrome, allows a remote attacker to achieve arbitrary code execution inside the browser's renderer sandbox by convincing a victim to open a crafted HTML page. All desktop Chrome builds prior to 155.0.8059.79 (stable and extended-stable channels) are affected, and exploitation requires user interaction (UI:R), which limits mass or automated abuse. No public exploit code has been identified at time of analysis and CISA's SSVC assessment rates exploitation as none; however, CISA assigns a total technical impact once the bug is triggered, and Google rates the Chromium security severity as High. The primary constraint on real-world impact is that code execution is confined to the renderer sandbox, so full host compromise would additionally require chaining a separate sandbox-escape vulnerability.
Use-after-free in the Canvas rendering path of Google Chrome versions prior to 155.0.8059.79 allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page, requiring user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R, base 8.8). Because the freed object is reused in a graphics-rendering context, exploitation yields code execution only within the renderer sandbox, so full host compromise would require chaining a separate sandbox-escape flaw. No public exploit identified at time of analysis, and CISA's SSVC assessment rates exploitation as 'none' and automatable as 'no', though technical impact is rated 'total' if the bug is successfully triggered; a vendor-released patch (155.0.8059.79) is available.
A use-after-free in Google Chrome's Media component lets a remote, unauthenticated attacker who convinces a victim to load a crafted HTML page execute arbitrary code within the renderer sandbox (CVSS 3.1 base 8.8, vector AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). Only Chrome builds prior to 155.0.8059.79 are affected, and because the scope is unchanged (S:U) any meaningful escape from the browser sandbox would require chaining a separate sandbox-escape flaw. No public exploit code has been identified at time of analysis, CISA's SSVC assessment rates exploitation as none with automatable exploitation as no, and a vendor patch (155.0.8059.79) is available - the overall picture is a genuine, high-severity memory-corruption bug that nonetheless does not warrant top-tier emergency handling.
Heap buffer overflow in ANGLE, Chrome's graphics translation layer, allows a remote attacker to potentially execute arbitrary code outside the browser sandbox on Android. Chrome on Android builds prior to 155.0.8059.79 are affected, and the attack requires no authentication (PR:N) but does require the victim to render attacker-controlled web content (UI:R), with a CVSS base score of 9.6 and a scope change indicating sandbox-escape impact. No public exploit code has been identified at time of analysis, no CISA KEV entry exists, and SSVC rates exploitation as 'none' with automatable 'no', although technical impact is rated total and Google classifies the issue as Critical (Chromium security severity: Critical).
Remote code execution inside the Chrome renderer sandbox is possible via a use-after-free in the Media component of Google Chrome versions prior to 155.0.8059.79. An unauthenticated remote attacker can trigger the flaw by inducing a victim to load a crafted HTML page containing malicious media content; the CVSS vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) confirms that no privileges are needed but that user interaction is required, and that any code execution is confined to the renderer sandbox unless chained with a separate sandbox escape. Google rates the Chromium severity as Critical, a vendor patch in 155.0.8059.79 is available, and no public exploit code has been identified at time of analysis.
Use-after-free in the Chrome Browser process before version 155.0.8059.79 allows a remote attacker to execute arbitrary code outside the sandbox when a victim loads a crafted HTML page. Google rates this Chromium security severity Critical, and the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6) reflects confirmed high confidentiality, integrity and availability impact with a sandbox-escape scope change; only user interaction - opening the malicious page - is required, and no authentication or prior access is needed. At the time of analysis there is no CISA KEV listing and no public exploit code identified, although weaponization of Chrome browser-process use-after-frees is a realistic near-term concern given the sandbox-escape payoff. Vendor patch: Google shipped a fix in the 155.0.8059.79 stable channel release.
Use-after-free in Google Chrome's SVG rendering path allows a remote, unauthenticated attacker to execute arbitrary code inside the renderer sandbox when a victim opens a crafted HTML page, affecting all desktop builds prior to 155.0.8059.79 on both the Stable and Extended Stable channels. Exploitation requires user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8), and because the scope is unchanged (S:U) the attacker gains renderer-process code execution, not host compromise, unless the primitive is chained with a separate sandbox escape. Chromium rates the flaw Critical, but all available exploitation signals are currently negative: CISA's SSVC assessment records Exploitation: none, and no public exploit code has been identified at time of analysis. Google has released a vendor patch in Chrome 155.0.8059.79.
Use-after-free in Google Chrome's built-in PDF handling lets a remote attacker achieve arbitrary code execution inside the browser sandbox by getting a victim to open a crafted HTML page containing malicious PDF content, affecting all desktop Chrome builds prior to 155.0.8059.79. Exploitation requires user interaction (UI:R) but no authentication (PR:N), and because the corrupted free happens in the renderer, code execution is contained by Chrome's sandbox - full host compromise would require chaining a separate sandbox-escape bug. CISA's SSVC assessment records no observed exploitation and no public exploit identified at time of analysis, so this is a genuine but not emergency-grade priority; Google rates the Chromium security severity as High and a vendor patch is available.
Use-after-free in Google Chrome's Passwords component (desktop stable builds prior to 155.0.8059.79) allows an attacker who has already compromised the renderer process to execute arbitrary code outside the browser sandbox by convincing a victim to load a crafted HTML page. The 8.3 CVSS score reflects high confidentiality, integrity, and availability impact with a changed scope, but it is unauthenticated on paper (PR:N) only in the sense that no credentials are checked - the real gate is the prerequisite renderer compromise plus a hard-to-win use-after-free race (AC:H) and required user interaction (UI:R). No public exploit code and no confirmed active exploitation (not in CISA KEV) were identified at time of analysis, and Google has already released a fixed build, so the signals point to lower real-world urgency than the raw score suggests.
Incorrect authorization in Chrome's Mojo IPC layer on Windows prior to 155.0.8059.79 allows a local attacker - a low-privileged user or code already running inside a Chrome child process - to escape the sandbox and execute arbitrary code with the browser's privileges; the flaw is a privilege boundary failure in the browser process, not a remote code-execution bug reachable by a web page alone. Exploitation requires a foothold on the Windows host: either a malicious local program or, in the more typical Chrome scenario, a compromised sandboxed renderer that chains this bug to break out. There is no public exploit identified at time of analysis and no CISA KEV listing, and a vendor patch is available; NVD's 9.6 score (AV:N/UI:R) overstates reachability compared with the independently assessed vector (AV:L/PR:L/UI:N), so the practical risk profile is a post-compromise sandbox escape rather than an unauthenticated network attack.
Use-after-free in Google Chrome's FileSystem component (CWE-416) lets an unauthenticated remote attacker execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page in any build prior to 155.0.8059.79. The 9.6 CVSS score is driven by the scope change (S:C) that models the sandbox escape plus high confidentiality, integrity and availability impact, yet exploitation requires mandatory user interaction (UI:R) and CISA's SSVC rates the attack non-automatable with exploitation status 'none', while Google itself assigns only Medium severity - sharply conflicting signals that should be reconciled before prioritization. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV).
Type confusion in the V8 JavaScript engine of Google Chrome allows remote attackers to achieve arbitrary code execution inside the renderer sandbox when a victim loads a crafted HTML page, affecting all builds prior to 155.0.8059.79. Exploitation requires no credentials (PR:N) but does require user interaction - the target must navigate to or be served attacker-controlled web content - and the resulting code execution remains confined to the renderer process, so a separate sandbox escape would be needed for host-level compromise. No public exploit code has been identified at time of analysis, there is no confirmed active exploitation (not in CISA KEV), and EPSS is low at 0.23% (13th percentile); Google has released a patched build and Chrome's automatic update mechanism shortens the practical exposure window.
Use-after-free in Google Chrome's Media component before version 155.0.8059.79 allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by convincing a user to open a crafted HTML page that drives the vulnerable media-parsing code path. Exploitation requires user interaction (the victim must navigate to or be redirected to attacker-controlled content), and the resulting code execution is confined to the sandbox, meaning host compromise would require chaining a separate sandbox-escape flaw. No public exploit code has been identified at time of analysis, EPSS is low (0.21%, 11th percentile), and Google has released a fixed build, so risk is serious but not emergency-level; priority should follow normal rapid-patching timelines.
Use-after-free in Google Chrome's ShapeDetection implementation, affecting all versions prior to 155.0.8059.79, allows an attacker who has already compromised the renderer process to execute arbitrary code outside the sandbox, turning a renderer foothold into full browser-process compromise. Exploitation is not standalone: the CVSS vector (AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H) and the assessed conditions require both a prior renderer compromise achieved through a separate bug and user interaction, since the victim must load attacker-controlled crafted HTML that exercises the ShapeDetection API to trigger the free-then-reuse condition. Exploitation status is limited: no public exploit identified at time of analysis, no CISA KEV listing, and EPSS is low at 0.21% (11th percentile), though the SSVC technical impact is rated total because success means code execution beyond the Chrome sandbox.
Google Chrome before 155.0.8059.79 contains a use-after-free in its WebRTC component that can let a remote, unauthenticated attacker execute code inside the renderer sandbox when a victim loads a crafted HTML page, requiring user interaction. The issue is high severity (CVSS 8.8, CWE-416) and has a vendor patch, but sandbox containment means host-level compromise would require a separate escape. No public exploit has been identified at time of analysis and EPSS is 0.21% (11th percentile), so active exploitation is not currently indicated.
Remote code execution outside the sandbox in Google Chrome allows an unauthenticated attacker to execute arbitrary code on a victim's system by convincing them to open a crafted HTML page that loads a malicious PDF, affecting Chrome versions prior to 155.0.8059.79 on all platforms. This is a use-after-free (CWE-416) in the PDF component with a Critical Chromium severity and an assessed CVSS of 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H). Exploitation requires user interaction, and no public exploit identified at time of analysis; EPSS is low at 0.21% (11th percentile), and the vendor has released a patch (155.0.8059.79).
Privilege elevation in Microsoft SQL Server lets an attacker who already holds high-privilege credentials on the instance trigger a stack-based buffer overflow over a network connection and break out of their authorization boundary. Exploitation is constrained: the CVSS vector (AV:N/AC:H/PR:H/UI:N/S:C) and the vendor description both indicate an authorized, highly privileged principal is required, and the AC:H rating means the overflow depends on specific server state, data, or timing rather than trivial input, so it is not reliably repeatable on a first attempt. All affected GDR and CU builds are pre-patch, Microsoft has published a fix via the MSRC update guide, and no public exploit or confirmed active exploitation was identified at time of analysis, so risk is real but conditional rather than a drop-everything emergency.
Command injection in MultiTail 7.1.5 and earlier lets an attacker who can write content into a monitored log or stream execute arbitrary shell commands as the user running MultiTail, because matched text is concatenated into a command passed to sh -c with only partial escaping. Exploitation is gated by a deliberate, non-default configuration: the operator must have enabled the -ex/-eX execute-on-match feature with a filter regex, and the injected line must match that regex; because the CVSS vector is AV:L/PR:L/UI:R, this is a local, low-privileged, user-interaction-dependent issue with impact bounded by the privileges of the MultiTail process. Exploitation code is publicly available (CISA SSVC reports Exploitation: poc), but there is no evidence of confirmed active exploitation, and the assessed risk is moderate and internally consistent rather than alarming.
Authentication bypass in Microsoft .NET allows an unauthenticated, remote attacker to forge a cryptographic signature and have it accepted by applications that rely on the framework's signature-verification routines, potentially leading to unauthorized access or token misuse. The JWT Attack tag points to a token-signature validation weakness; exploitation requires the target application or user to process the attacker-supplied signed token (UI:R), which limits reachability for purely passive endpoints. Affected versions include .NET 10.0 before 10.0.402, .NET 11.0 before 11.0.100-rc.2, and the listed Visual Studio 2022 17.14.x/2026 18.10.x builds; vendor patches are available, and no public exploit identified at time of analysis.
Code execution in .NET and Visual Studio can be triggered when a developer or user processes attacker-supplied content - such as a crafted project, build input, or dependency - that pulls functionality in from an untrusted control sphere and executes it. Affected builds are .NET 8.0 before 8.0.132, .NET 9.0 before 9.0.319, .NET 10.0 before 10.0.113, Visual Studio 2022 17.14 before 17.14.42, and Visual Studio 2026 18.10 before 18.10.4; the issue is network-reachable and unauthenticated (PR:N) but requires user interaction (UI:R) and non-trivial preconditions (AC:H), so an attacker cannot silently trigger it remotely. There is no public exploit identified at time of analysis and no confirmed active exploitation - the CISA SSVC exploitation value is 'none' - which keeps this a moderate-priority issue rather than a drop-everything emergency despite the 7.5 High CVSS score, especially since the SSVC technical impact is assessed as 'total' once exploitation conditions are met.
Unauthenticated remote denial of service in ASP.NET Core (8.0 before 8.0.32, 9.0 before 9.0.21, 10.0 before 10.0.13, and 11.0 before 11.0.0-rc.2) lets a network-reachable attacker exhaust resources because request processing is not adequately bounded or throttled, degrading or halting availability of hosted applications. Per the assessed CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, exploitation requires no credentials, no user interaction, and no special configuration, but impact is confined to availability - no data disclosure or code execution results. No public exploit identified at time of analysis and SSVC records exploitation as none, though the flaw is rated automatable, meaning exploit tooling could be developed; patched framework builds and updated Visual Studio tooling are available from Microsoft.
An out-of-bounds write (CWE-787) in ASP.NET Core and the associated .NET runtimes lets a remote, unauthenticated attacker trigger memory corruption that crashes or destabilizes a network-reachable service, yielding a full loss of availability (CVSS 3.1 base 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). Exploitation requires no credentials, no user interaction, and no special configuration - only that the target endpoint be reachable and running an unpatched build (for example .NET 8.0 below 8.0.32, .NET 9.0 below 9.0.21, or .NET 10.0 below 10.0.13). There is no public exploit identified at time of analysis and CISA's SSVC rates exploitation as "none" while marking the flaw fully automatable, so scripted denial-of-service attempts remain a plausible near-term risk; vendor patches are available.
Local privilege escalation in the .NET runtime (8.0, 9.0, 10.0, and 11.0 preview) and in Visual Studio 2022 17.14 and Visual Studio 2026 18.10, which ship affected runtime builds, allows an authenticated local attacker to gain higher-privileged file access or code execution by crafting a symbolic or hard link that a more privileged .NET or IDE process later resolves. Exploitation requires prior low-privileged local access to the host and typically depends on winning a timing/race condition against a privileged process (CISA SSVC Automatable: no), which confines realistic risk to developer workstations, build servers, and CI agents rather than general end-user endpoints. The issue scores 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) with total technical impact, no public exploit has been identified at time of analysis, and vendor-released patches are available. This is a credible but not emergency-grade issue, best treated as routine-high patching priority rather than a drop-everything event.
Cross-site scripting (CWE-79) in the ASP.NET Core Blazor WebAssembly Server hosting component allows an unauthenticated, network-based attacker to execute arbitrary script in a victim's browser session by getting attacker-influenced input rendered into a web page without proper HTML neutralization. Affected are applications built on Microsoft.AspNetCore.Components.WebAssembly.Server 10.0.0 through <10.0.13, as well as apps produced by the vulnerable Microsoft Visual Studio 2026 18.10.x (<18.10.4) and Visual Studio 2022 17.14.x (<17.14.42) toolchains. Exploitation is not automatable per CISA SSVC and requires mandatory user interaction (CVSS UI:R) - the victim must load or interact with the crafted content - and no public exploit code or active exploitation has been identified at time of analysis; vendor patches are available, so risk is primarily to unpatched, internet-facing Blazor WebAssembly deployments.
Local privilege escalation in Microsoft .NET (CWE-59 link following) lets an authenticated attacker with existing low-privileged code execution escalate to higher privileges by creating symbolic links or junctions and winning a link-resolution race against a privileged .NET file operation. Affected builds include .NET 8.0 before 8.0.32, 9.0 before 9.0.21, 10.0 before 10.0.13, 11.0 before 11.0.0-rc.2, Microsoft Visual Studio 2022 17.14 before 17.14.42, and Microsoft Visual Studio 2026 18.10 before 18.10.4. No public exploit code was identified at time of analysis, and CISA SSVC rates exploitation as none, so this is a post-compromise escalation primitive rather than an initial-access vector; vendor patches are available.
Ghostscript as shipped with Red Hat Enterprise Linux 8-and, per CPE data, RHEL 6, 7, 9, and 10-may allow an attacker to escape -dSAFER protections when it processes a crafted PostScript file, enabling file access outside permitted paths or command execution with the Ghostscript process's privileges. The root cause is that Red Hat's 9.25-to-9.27 rebase omitted the CVE-2019-14869 correction, leaving privileged .forceput operations in the .charkeys procedure insufficiently protected; the supplied CVSS base score is 7.3, while the independent assessment treats confidentiality and integrity impact as High (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L). No CISA KEV entry is present in the supplied data and no public exploit identified at time of analysis; practical risk is conditional on a service or pipeline actually processing untrusted PostScript/EPS with an affected RHEL build.
Red Hat Advanced Cluster Security for Kubernetes (RHACS) Central's SAML assertion consumer service (ACS) endpoint does not cache used assertion or response identifiers, so a single valid signed SAML response can be replayed to mint multiple distinct Central authentication tokens for the same mapped identity. Deployments are only exposed when Central is configured to authenticate via SAML; an attacker must first obtain a legitimately signed, unexpired SAML response - they cannot forge one - which is why the issue is rated CVSS 7.4 with high attack complexity despite requiring no privileges or user interaction. Successful replay yields full compromise of confidentiality and integrity for the impersonated identity; no public exploit code or confirmed active exploitation was identified at time of analysis, and non-SAML authentication configurations are unaffected.
Unbounded resource allocation in ASP.NET Core - reachable through the System.Formats.Cbor component shipped with Microsoft Visual Studio 2022 version 17.14 and Visual Studio 2026 version 18.10 - lets unauthenticated remote attackers exhaust server resources and cause a denial of service. The flaw is rated CVSS 7.5 (AV:N/AC:L/PR:N/UI:N, availability-only impact), meaning any network-exposed service that actually parses attacker-supplied CBOR input through the vulnerable path can be driven into resource exhaustion without credentials or user interaction. Exploitation is bounded by reachability: deployments that never process untrusted external CBOR/network data, or that sit behind request-size limits, rate limiting, timeouts, or a WAF, have materially reduced exposure. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV; a vendor patch is available via the Microsoft Security Response Center advisory.
Process-terminating denial of service in undici, the Node.js HTTP client, affecting versions 7.15.0 through 7.30.0 and 8.0.0 through 8.12.1. When an application composes the decompress interceptor with a downstream response handler that throws during response processing - most notably the built-in dump interceptor hitting its configured maximum response size - a remote server controlled or compromised by an attacker can return a tiny compressed body that expands past that limit, and the resulting throw originates asynchronously inside a zlib stream callback where undici's engine does not convert it into a per-request failure, so it surfaces as an uncaught exception that terminates the Node.js process. The assessed vector (AV:N/AC:L/PR:N/UI:N, availability-only, A:H) makes this an unauthenticated remote crash with low attack complexity, but exposure is bounded because the vulnerable interceptor pairing is not undici's default behaviour and only the listed version ranges are affected. Vendor patches are available in 7.30.1 and 8.12.2, EPSS is low at 0.25% (15th percentile), SSVC records exploitation as none and automatable as no, and no public exploit code was identified at time of analysis.
Denial of service in AdonisJS HTTP Server (adonisjs/http-server) lets unauthenticated remote attackers stall the Node.js event loop: versions prior to 8.2.2 and 9.1.1 contain a catastrophic-backtracking regular expression in router.matchers.slug(), and a long slug ending in a character rejected by the final assertion triggers quadratic CPU consumption. Because the matcher runs during route matching and before route and group middleware, authentication or rate-limiting middleware attached to the affected route does not prevent the request from blocking the worker and starving unrelated requests and health checks. Impact is availability-only with no data exposure, the CVSS 4.0 base score is 8.7 (assessed CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), no public exploit identified at time of analysis, and exploitation requires the application to explicitly apply the slug matcher to an externally reachable, attacker-controlled route parameter rather than affecting every AdonisJS deployment.
Denial of service in the undici HTTP client library for Node.js allows any attacker-controlled or compromised HTTPS endpoint to terminate the client process by performing a TLS 1.2 renegotiation. When a server renegotiates after the connection is established and presents a different CA-trusted certificate whose hostname does not match the requested host, Node.js re-runs hostname verification and destroys the socket with a certificate-altname error; undici's established-socket error handler treated that error code as impossible, so the peer-controlled condition became an uncaught assertion (CWE-248) that crashes Node.js and kills all in-flight requests and background work. The flaw affects undici 4.2.1 through 6.29.0, 7.0.0 through 7.30.0, and 8.0.0 through 8.12.1 on both the HTTP/1.1 and HTTP/2 paths, and is reachable through Node's global fetch() as well as direct library use; it is remotely triggerable without authentication or a CA compromise (CVSS 3.1 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), though only TLS 1.2 connections are exploitable since TLS 1.3 removed renegotiation. No public exploit code was identified at time of analysis and there is no indication of confirmed active exploitation, but exploitation is trivial for any adversary who can serve an endpoint the victim fetches from, and patched releases 6.29.1, 7.30.1, and 8.12.2 are available.
Unauthenticated remote requests can crash Go services that embed kin-openapi before 0.148.0: posting a YAML body containing .nan, .inf, or -.inf to an OpenAPI 3.1 operation carrying a numeric constraint drives the bundled santhosh-tekuri/jsonschema v6.0.2 into a nil big.Rat dereference, panicking inside ValidateRequest. The assessed CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (7.5), reflecting availability-only impact: a standard net/http server recovers the panic per connection so the effect is usually a single dropped request, while non-net/http hosts or panics raised in application goroutines can terminate the process. No public exploit code has been identified at time of analysis and there is no evidence of confirmed active exploitation; the need to reach an OAS 3.1 spec, accept application/yaml (or application/x-yaml), and hit an operation with a numeric constraint keeps this a genuine but bounded denial-of-service issue.
Path traversal in wildfly-core's deployment content handler allows an authenticated JBoss EAP, WildFly, Fuse 7, or Single Sign-On 7 user who holds the Deployer RBAC role to escape the restricted deployment directory and create files with attacker-controlled content or delete arbitrary directories on the server, escalating to full management SuperUser privileges. Exploitation requires that the Deployer role be delegated to the attacker (CVSS vector shows PR:L - authenticated, not anonymous) plus a crafted deployment name containing traversal sequences; environments that reserve the Deployer role for fully trusted administrators face little practical exposure. No public exploit code was identified at time of analysis and the flaw is not listed in CISA KEV, so this is a credible, actionable priority rather than an emergency.
An unauthenticated remote request can slip past kin-openapi's openapi3filter authentication middleware and reach a handler that was meant to be protected, when the library's ValidationHandler is used as middleware in front of a gorilla/mux router configured with UseEncodedPath. The library validates the operation it derives from the decoded URL.Path (0.144.0 through 0.146.x), while the downstream mux router, using the raw encoded path, dispatches to a different, protected parameterized route that overlaps the public exact route after decoding - so requests carrying an encoded slash (%2F) can be validated as the public operation and then served by the protected handler without the configured AuthenticationFunc ever running. Reaching the flaw requires a precise deployment stack (kin-openapi >=0.144.0 <0.147.0, ValidationHandler wired as auth middleware, mux with UseEncodedPath, and an overlapping public exact route plus protected parameterized route sharing an HTTP method), which is reflected in the CVSS 7.4 rating with AC:H; no CISA KEV listing, and no public exploit identified at time of analysis, though the upstream fix commit includes a regression test that reproduces the bypass.
A nil-pointer panic in kin-openapi's openapi3filter validation path can crash any Go service that embeds versions 0.136.0 through 0.142.x and serves an OpenAPI 3.1 document with an array schema that omits the items keyword. Unauthenticated remote clients (CVSS vector PR:N/UI:N) only need to send a single nonempty application/x-www-form-urlencoded or multipart/form-data request to an affected operation - or trigger a matching response on a surface such as a response header - to deterministically panic ValidateRequest or ValidateResponse, producing denial of service with no confidentiality or integrity impact (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, CVSS 7.5). The risk is real but bounded: only OpenAPI 3.1 specs containing the specific malformed-but-spec-legal array shape are exposed, JSON request bodies use a different decoder, and OpenAPI 3.0 documents are rejected at validation time. No public exploit code has been identified at time of analysis, and there is no confirmed active exploitation.
Memory corruption in the Linux kernel IPv4 receive path lets a local attacker who can inject a packet with malformed checksum metadata (an out-of-range skb checksum_start) into the host IPv4 stack cause skb_checksum_help to write into and corrupt the network header, yielding high-integrity and high-confidentiality impact with a changed security scope (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H, 9.3). The flaw is realistically reachable by an unprivileged process inside a sandbox, container, or guest VM that can supply attacker-controlled checksum metadata to the host kernel, making multi-tenant and sandboxed environments the primary exposure; single-tenant systems with no untrusted local or sandboxed workloads are materially less exposed. Exploitation requires local access only (no remote network path indicated), and intelligence available at the time of analysis shows no confirmed active exploitation (no CISA KEV) - though linked references to sandbox-escape research (pwn.ai's 'Pwnescape' and Vercel's $1M sandbox challenge findings) indicate the underlying primitive is being actively studied.
Eclipse Jetty's host whitelist/blacklist enforcement in the jetty-server and jetty-proxy modules performs case-sensitive comparisons, so a remote, unauthenticated attacker can bypass the filter simply by altering the letter case of the Host value (e.g. 'EXAMPLE.com' instead of 'example.com') and reach hosts the operator intended to block or exclude. The flaw only matters where an operator has explicitly configured a host whitelist or blacklist and treats it as a security boundary; deployments without host-based filtering are unaffected. The vendor has published a security advisory (GHSA-7wfj-j486-mxrf), and no public exploit code has been identified at time of analysis, though the low attack complexity (AC:L, PR:N, UI:N) and high confidentiality impact make the bypass straightforward to attempt wherever the non-default filtering configuration is present.
Arbitrary file overwrite in HPE NonStop Python 3.x lets an attacker who supplies a crafted TAR archive escape the intended extraction directory via .. (dot-dot) sequences in member filenames and clobber files on the NonStop host, with the overwritten data potentially leading to code execution or system compromise depending on the privileges of the extracting process. The vendor rates this 8.0 (CVSS:3.1/AV:A/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), while our independent assessment scores it lower at CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:H, treating it as local rather than adjacent-vector and integrity/availability-only; unauthenticated access is implied by PR:N in both vectors, but successful exploitation is not automatic - it requires the victim to extract an attacker-controlled archive (UI:R), and the write primitive is bounded by the privileges of the extracting account. No public exploit code was identified at time of analysis, there is no CISA KEV entry, and no EPSS score was supplied, so real-world risk is moderated by the mandatory user interaction rather than by the headline score.
Eclipse Jetty's HttpClient can disclose proxy authentication credentials to a malicious server when the server returns a 407 Proxy Authentication Required status. This information disclosure (CWE-200) affects applications using Jetty's HttpClient with an authenticated forward proxy and connecting to attacker-controlled destinations. Exploitation requires the attacker to control the destination server and the client to be configured with proxy credentials; no public exploit code has been identified at time of analysis, and the CVSS 4.0 score is 8.2 (High).
Path-normalization weakness in Eclipse Jetty's HttpClient causes credential disclosure: when HttpClient receives a redirect whose target contains a non-normalized traversal segment such as /secure/../evil, Jetty matches the stored Authorization credential against the literal /secure prefix rather than resolving the path to /evil, and then follows the redirect - sending the /secure-scoped Authorization header to an endpoint that should never receive it. Per the provided CVSS vector (PR:N) the attacker is unauthenticated, but exploitation carries high attack complexity (AC:H): the attacker must be able to control or influence the redirect response returned to HttpClient, and must already have a malicious application deployed on the SAME domain as the target so the leaked header lands on an endpoint they control. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Denial of service in Nodemailer 3.0.0 through 10.0.9 allows an attacker-controlled or on-path SMTP server to stall a Node.js application by streaming SMTP continuation lines that never deliver a terminating completion line during the greeting/authentication phase. The vulnerable reply parser in SMTPConnection._onData and isPartialResponse re-evaluates its buffered response on every incoming chunk, so parsing cost grows quadratically with the size of the accumulated reply, blocking the single-threaded event loop and consuming memory before authentication completes. No public exploit code was identified at time of analysis, and exploitation is conditional: the client must be configured to connect to an untrusted or attacker-influenceable SMTP server, or an attacker must be positioned on-path on an interceptable SMTP connection, which is why the assessed vector carries AC:H and AT:P and this is a genuine but conditional availability risk rather than a blanket critical one.
Denial of service in Nodemailer 3.0.0 through 10.0.12 lets a malicious or man-in-the-middle SMTP server stall the Node.js event loop by answering EHLO with a crafted '250-AUTH' line followed by a long whitespace run and a non-matching token, which drives quadratic backtracking in the four AUTH-mechanism detection regexes in SMTPConnection._actionEHLO. No authentication is required from the attacker (PR:N) and the trigger occurs before any authentication step, but the victim application must connect outbound to an attacker-controlled or interceptable SMTP endpoint, so deployments pinned to fixed, trusted, TLS-authenticated mail servers are substantially harder to exploit. Impact is confined to event-loop blocking and availability loss (no confidentiality or integrity effect), and no public exploit code was identified at time of analysis; the vendor fix is Nodemailer 10.0.13.
Server-side request forgery in Renovate before 44.79.0 allows authenticated users with low privileges to direct the shared HTTP client at arbitrary internal URLs through 'extends' preset references or 'customDatasources' entries. An attacker who can influence Renovate's configuration - for example by committing to a scanned repository or controlling a preset source - can reach an instance metadata endpoint such as AWS IMDS to obtain credentials, or exfiltrate sensitive information into Renovate logs; real-world impact depends on the deployment's network reachability of internal services. The vendor fixed the issue in Renovate 44.79.0, and no public exploit code has been identified at time of analysis.
Renovate before 44.60.1 permits authenticated repository users with configuration influence to circumvent the allowedHeaders restriction by embedding hostRules[].headers inside shared presets, causing custom HTTP headers to be injected into outbound requests Renovate makes to other hosts. This is an allowlist/authorization bypass requiring low privileges (PR:L per CVSS) and specific, condition-dependent prerequisites (AC:H), making it an insider or supply-chain-style abuse rather than anonymous remote exploitation. It is not confirmed as actively exploited (no CISA KEV entry) and no public exploit code has been identified at time of analysis.
Arbitrary file read in GitPython before 3.2.0 occurs when a vulnerable application clones an attacker-controlled repository and then calls Head.checkout() on the repository's default branch; a branch named like --pathspec-from-file=<path> is parsed by Git as an option rather than a branch, causing readable file contents to be leaked through GitCommandError messages. This is a credible but conditional information-disclosure flaw, not a drop-everything emergency: only confidentiality is affected, exploitation requires the target to process untrusted repositories and surface error output, and no public exploit identified at time of analysis. Unauthenticated network exploitation is possible per the PR:N vector, and the vendor patch is GitPython 3.2.0.
Remote code execution in GitPython releases before 3.2.0 (CVE-2026-110857) allows unauthenticated attackers to execute arbitrary commands through Git.ls_remote, which forwards a caller-supplied remote URL without the check_unsafe_protocols validation that normally blocks dangerous transports, notably ext:: remote-helper URLs when Git's protocol.ext.allow setting permits them. Exploitation is conditional rather than trivial: a consuming application must pass an attacker-controlled URL into the affected API (user interaction is required per the assessed CVSS:3.1 vector AV:N/AC:H/PR:N/UI:R), and a default Git configuration that rejects the ext transport blocks the primary ls_remote path, while the related merge_base and IndexFile.move option-injection paths remain similarly unguarded. No public exploit identified at time of analysis; the flaw is fixed in GitPython 3.2.0.
Information disclosure in GitPython before 3.2.0 lets attackers leak environment-variable secrets through crafted submodule names in a repository's .gitmodules file. The flaw occurs when Repo._clone() calls Git.polish_url() without expand_vars=False, so variable syntax in a submodule name is expanded during clone plus submodule_update and the resulting values surface in .git/modules directory names and DEBUG logs. Exploitation is unauthenticated per the CVSS vector (PR:N) but requires the victim to clone an attacker-supplied repository and invoke submodule handling, and leakage only materializes if sensitive values are present in the process environment; no public exploit code, CISA KEV entry, or EPSS score was identified in the provided data, and integrity and availability are unaffected (CVSS 4.0 base 7.1, moderate severity).
Memory corruption in FreeRDP's grayscale JPEG clipboard conversion can crash the RDP client when a malicious server delivers a crafted clipboard item that the victim pastes as CF_DIB bitmap data. The flaw is a heap-based out-of-bounds write in winpr_convert_from_jpeg, affecting versions 3.3.0 up to but not including 3.32.0 that are built with the non-default WINPR_UTILS_IMAGE_JPEG=ON option. Exploitation requires the victim to connect to an attacker-controlled RDP server with clipboard redirection active and to actively paste the malicious grayscale JPEG; no public exploit code has been identified at time of analysis, and the impact is primarily availability-focused (crash) with limited integrity impact.
Unauthenticated keyboard injection in the FreeRDP shadow server (versions 3.0.0 through 3.31.x) allows remote attackers to send synthetic keystrokes into a host user's X11 session via XTEST by delivering an input PDU during the Confirm Active state, before any authentication takes place. Exploitation requires the shadow/mirroring server to be network-reachable and the host to be running an X11 session over a TLS-only RDP negotiation; the confirmed impact is integrity-only (fabricated input) with no confidentiality or availability effect. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV.
Null pointer dereference in FreeRDP versions 2.0.0 through 3.31.x allows a malicious RDP server to crash Linux clients that have serial-port redirection enabled. The attacker sends IRP_MJ_READ or IRP_MJ_WRITE requests either before the serial channel is created or after it is closed, causing CommReadFile or CommWriteFile to dereference a null handle and terminate the client. This is an availability-only issue (CVSS 4.0 score 7.1, no confidentiality or integrity impact) that requires the victim to initiate a connection to the attacker-controlled server and have serial redirection active; no public exploit code has been identified at time of analysis.
Unbounded heap accumulation in the FreeRDP proxy (the pf/proxy relay component) lets unauthenticated remote attackers exhaust proxy memory by streaming RDPDR device-redirection fragments that begin with a FIRST fragment but never carry a LAST fragment, so reassembly state grows in proportion to bytes sent. Affected deployments are FreeRDP 3.0.0-beta1 through versions before 3.32.0 that run the proxy with the RDPDR channel reachable from untrusted clients; plain FreeRDP client or server deployments are not the stated target. Rated CVSS 4.0 8.2 (High), with assessed CVSS 3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, this is a slow-burn memory-exhaustion DoS requiring sustained fragment traffic rather than a single packet, and there is no public exploit identified at time of analysis.
Authenticated RDP clients can force unbounded server-side memory allocation in FreeRDP 2.0.0 through 3.31.x by sending a seven-byte DATA_FIRST message on an already-opened dynamic virtual channel (DVC) that declares a large 32-bit length, driving zeroed resident-memory growth until the server's resources are exhausted and service is denied. The flaw is availability-only (CWE-400 resource exhaustion; CVSS 4.0 base 7.1, assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H) with no code execution or data disclosure impact, and every action requires a valid authenticated session plus a successfully opened DVC - so real exposure depends on who can authenticate to the RDP service, and it is not remotely exploitable without credentials. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis.
Client termination in FreeRDP before 3.32.0 occurs when a malicious RDP server sends repeated serial IRP_MJ_CREATE requests, causing the client to accumulate file descriptors until it hits the CommReadFile FD_SETSIZE assertion and crashes. The flaw requires the non-default serial/COM port redirection channel to be active and the victim to connect to an attacker-controlled or compromised server; it is an unauthenticated remote denial of service with no code execution or data exposure. No public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis.
Null pointer dereference in the FreeRDP client's rdpsnd (audio redirection) channel allows a malicious or compromised RDP server to crash any connecting client running FreeRDP 3.0.0 through 3.31.x, producing a denial of service that terminates the user's RDP session. The trigger is a malformed rdpsnd fragment that sets CHANNEL_FLAG_LAST without CHANNEL_FLAG_FIRST and arrives on a fresh channel; the CVSS vectors (4.0 AV:N/AC:L/AT:N/PR:N/UI:P/VA:H, and the assessed 3.1 equivalent AV:N/AC:L/PR:N/UI:R/A:H) confirm unauthenticated remote reach but strictly availability-only impact - no confidentiality, integrity, or code-execution effect. Exploitation requires the victim to initiate a session against the attacker's server and to have audio redirection negotiated; there is no evidence of in-the-wild exploitation and no public exploit identified at time of analysis.
Guest-to-host out-of-bounds access in DPDK's vhost-crypto backend lets a low-privileged guest VM that is already attached to a vhost-crypto device corrupt host-side memory by racing the host's two reads of an indirect-descriptor next index, a classic TOCTOU double-fetch (CWE-367). Only hosts running DPDK with lib/vhost's vhost-crypto library enabled and actually processing indirect descriptors are exposed, and the race makes reliable exploitation non-trivial - the assessed vector is AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H, reflecting host-local reach via the guest with cross-boundary (guest-to-host) scope change. Red Hat tracks this for Fast Datapath packages on Red Hat Enterprise Linux 8, 9 and 10; no public exploit code has been identified at time of analysis and there is no CISA KEV entry. Realistic exposure is limited to multi-tenant, untrusted-guest or confidential-computing style deployments where the vhost-crypto feature is deliberately enabled.
A use-after-unmap in DPDK's vhost library gives a local attacker who controls a VDUSE (vDPA Device in USErspace) backend, or a guest able to drive IOTLB invalidations on the vhost device, a path to memory corruption inside the host vhost process. The flaw is that the VDUSE handler does not invalidate cached vring pointers when the IOTLB is invalidated, so the code keeps dereferencing vring addresses that have already been unmapped - a classic CWE-416 use-after-free. The assessed CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, base 8.8) marks this as locally reachable, low-complexity and low-privilege, with a scope change (S:C) reflecting that a confined guest/userspace VDUSE device can compromise the host vhost trust boundary; impact is full confidentiality, integrity and availability loss. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so risk is concentrated in multi-tenant virtualization and NFV hosts that specifically enable DPDK VDUSE. Affected packages are Red Hat's Fast Datapath DPDK channel for RHEL 8, 9 and 10, with downstream exposure noted for RHEL, OpenShift Container Platform 4 and OpenStack Platform 13 Queens.
Authentication bypass in PgBouncer 1.17.0 through 1.26.0 allows an authenticated attacker who knows a valid password for at least one user in auth_file to impersonate another user that authenticates via SCRAM, including PgBouncer admin users and backend superusers, by sending a second StartupMessage during the SCRAM exchange against a non-existent database. The issue is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and stems from improper authentication (CWE-287). No public exploit identified at time of analysis, and the flaw does not grant access to users not authenticating via SCRAM.
Denial of service in the Erlang OTP ssl application allows a malicious or man-in-the-middle TLS 1.3 server to crash the node-global session-ticket store on a connecting client, and repeated crashes can exhaust the ssl supervisor restart intensity and take down TLS for every connection on that node. The victim must be a TLS 1.3 client running OTP 23.3 through the fixed releases with session_tickets set to auto (automatic ticket storage and resumption); the crash does not occur when the bogus ticket is received but on the next automatic resumption attempt, and it requires the client to initiate the outbound connection, which is reflected in the assessed AT:P attack-requirement metric and a CVSS 3.1 base of 5.9 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H) despite the vendor's CVSS 4.0 score of 8.2. No public exploit code has been identified at time of analysis and there is no CISA KEV listing, but vendor patches and upstream commits are available. Reported by the Erlang Ecosystem Foundation (EEF) and tracked as EUVD-2026-101384.
A crafted DOS (MBR) extended-partition image can trigger a 32-bit integer overflow in util-linux's libblkid partition parser before version 2.41.4, causing the library to report a bogus partition that overlaps the master boot record. An unprivileged local attacker only needs to get a malicious disk image or removable medium in front of a probing path - such as automatic udev/udisks inspection of an inserted USB device, or any tool, VM, or forensic pipeline that scans attacker-supplied images - and no public exploit code or confirmed active exploitation has been identified at time of analysis. The realistic impact is limited: libblkid's reported partition metadata is falsified (an integrity issue), while actual disk modification or availability loss would require a separate downstream consumer to trust and act on that incorrect metadata, so the practical risk is modest despite a higher CVSS base score in some feeds.
A double-offset error in DPDK's vhost log-mapping calculation (lib/vhost) lets local attackers with low privileges (PR:L) - including a guest that controls a virtio device serviced by the vulnerable vhost-user backend - trigger incorrect host memory accesses that compromise confidentiality, integrity and availability, giving a 7.8 HIGH rating (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The flaw is tracked by Red Hat and ships in Fast Datapath for RHEL 8, 9 and 10, which in turn is consumed by Red Hat Enterprise Linux 8/9/10, OpenShift Container Platform 4 and OpenStack Platform 13 (Queens), so exposure is concentrated in OVS-DPDK accelerated virtualization and NFV hosts that exercise the vhost log-mapping path (for example during guest dirty-page logging/live migration). No public exploit identified at time of analysis, and no CISA KEV listing or exploit code is referenced in the available intelligence.
Heap buffer overflow in DPDK's lib/vhost VDUSE control-queue handler allows a local, low-privileged (authenticated) actor to corrupt heap memory with attacker-controlled content, enabling privilege escalation and loss of host integrity. The root cause is a time-of-check-to-time-of-failure (TOCTOU) double-fetch: the control-queue descriptor is read twice from memory the attacker can modify in between, so the length used for the copy can differ from the length that was validated. Only deployments that actually exercise the VDUSE (vDPA Device in Userspace) control-queue path are exposed, and because winning the race is probabilistic the CVSS base score of 7.8 (AV:L/AC:L/PR:L) is more realistically an AC:H scenario per our assessment; no public exploit code and no confirmed active exploitation were identified at time of analysis. This is a genuine privilege-escalation and host-integrity concern rather than a mass-exploitation threat, since it is strictly local, involves no remote network path, and requires controlling the descriptor memory between fetches.
Local privilege escalation in the SUID-root mount(8) utility shipped with util-linux 2.39.1 through 2.41.4 and 2.42 through 2.42.1, where the attacker-controlled LIBMOUNT_FORCE_MOUNT2 environment variable is read with getenv() and can force the legacy, non-atomic multi-step bind-mount path. On hosts whose /etc/fstab contains a bind mount authorized for unprivileged use via the user or users option and hardened with nosuid, noexec, or nodev, a local low-privileged user can win a timing race between the initial bind mount and the follow-up remount that applies those protective flags, briefly exposing an unprotected mount from which a SUID binary can be executed to obtain root. Exploitation is conditional (it requires that specific non-default fstab configuration) and non-deterministic because it depends on a race window; no public exploit code was identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV). Vendor-released patches are available in util-linux 2.41.5 and 2.42.2.
Buffer overflow in the DPDK vhost-user backend's split-ring inflight descriptor table handling allows a guest VM with code execution to corrupt host memory, potentially leading to code execution on the host. This high-severity flaw (CVSS 8.8) is the most critical issue in a bundled DPDK security advisory and affects multi-tenant deployments where the split-ring inflight feature-used for vhost-user reconnection and live migration-is enabled. No public exploit code has been identified at the time of analysis.
Local privilege escalation to root in util-linux's libmount affects versions 2.17 through 2.41.6 and 2.42 through 2.42.3, and also 2.42.4 when the legacy mount(2) path is used without /proc available. A local, low-privileged user who is already authorized by an /etc/fstab entry carrying the user or users option can exploit a time-of-check/time-of-use race: libmount validates the fstab target path and then the mount operation re-resolves that pathname, so an attacker who controls a writable ancestor directory can use renameat2(RENAME_EXCHANGE) to swap a path component and redirect the authorized mount to a root-owned location such as /etc/sudoers.d, gaining root. Exploitation is local only, requires the attacker to already hold an fstab mount authorization plus a writable ancestor on the configured target, and depends on winning the race (assessed AC:H), so it is non-deterministic; patched code paths using the new mount API (2.41.5 / 2.42.2 and later) or 2.42.4 with /proc present are not affected, and no public exploit identified at time of analysis.
Local privilege escalation in util-linux's SUID mount utility affects versions 2.39 through 2.41.4 and 2.42 through 2.42.1: a local, already-authorized low-privileged user can win a narrow timing race in the post-mount hook and redirect a privileged chmod()/lchown() onto a root-owned path, potentially obtaining root privileges. Exploitation requires a non-default /etc/fstab entry that combines the 'user' or 'users' mount option with an X-mount.mode, X-mount.owner, or X-mount.group option, plus write access to a writable ancestor directory of the mount target; the race itself is difficult (CVSS 3.1 7.0, AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H). No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has released fixes in 2.41.5 and 2.42.2.
Unauthenticated remote attackers can trigger a use-after-free in NGINX's ngx_http_core_module when asynchronous file I/O (AIO) is enabled and a Server Side Includes (SSI) page containing 'include virtual' commands is processed, causing memory corruption or a worker process crash. This affects both NGINX Plus and NGINX Open Source, with code execution possible only on systems where Address Space Layout Randomization (ASLR) is disabled or can be bypassed. Exploitation requires a non-default configuration (AIO and SSI enabled), and no public exploit code was identified at time of analysis.
Heap buffer overflow in NGINX Plus and NGINX Open Source can be triggered by crafted HTTP requests when a non-default map directive with regex matching is configured so that the root directive or access log format references the map's regex capture variables before the map output variable, or when a non-cacheable variable is used in a string expression under specific conditions. The flaw is remotely reachable without authentication (CVSS PR:N) but has high attack complexity (AC:H) because exploitation depends on conditions beyond the attacker's control and on a non-default configuration; the realistic outcome on systems with ASLR enabled is worker-process restart/DoS, while code execution is limited to systems with ASLR disabled or bypassed. F5 rates this CVSS 4.0 9.2 (Critical), and no public exploit identified at time of analysis.
SSL session ticket key handling in NGINX Plus and NGINX Open Source can let a remote unauthenticated attacker forge client SSL sessions and bypass client certificate verification, but only on instances that enforce mutual TLS and rely on NGINX's automatic ticket key rotation. Exploitation is conditional and non-deterministic: the affected deployments must be configured with ssl_session_cache shared:name:size and must not set an explicit ssl_session_ticket_key file, and the resulting forgery is beyond the attacker's control (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:L/A:N, 6.5). There is confirmed data-plane information exposure potential but no control-plane exposure, and no public exploit identified at time of analysis.
Heap buffer overflow in NGINX Plus and NGINX Open Source can be triggered by unauthenticated remote attackers through crafted HTTP requests, but only when a non-default configuration uses the alias directive together with rewrite and a set or return directive referencing the $request_filename variable, or when $request_filename is used in an access log format directive. Successful exploitation causes a heap buffer overflow in the NGINX worker process, leading to a restart (denial of service) and potentially allowing code execution on systems with ASLR disabled or bypassable. No public exploit code or active exploitation has been identified at time of analysis.
OS command injection in xhtml2pdf before 0.2.19 lets an attacker execute arbitrary OS commands as the invoking user when the pisa command-line tool is run with the -s/--start-viewer option against a file whose name contains a double quote plus shell metacharacters. The flaw lives in pisa.startViewer(), which interpolates an unescaped filename into os.system('open "%s"'); because the vulnerable path is only reached in viewer-launch mode, the default programmatic HTML-to-PDF conversion API is not affected. The vector is local and requires a user (or job) to actually launch the viewer, and no public exploit code has been identified at time of analysis - confirmed actively exploited status is not present in the available data.
Path-restriction bypass in BusyBox httpd's reverse proxy feature allows unauthenticated remote attackers to reach backend paths outside the configured forwarding prefix. When URL-prefix proxying is configured, only the first request on a TCP connection has its path rewritten; a pipelined second request is relayed verbatim, defeating the intended prefix restriction and exposing arbitrary backend routes. Affects BusyBox httpd deployments, including Red Hat Hardened Images, that enable the non-default reverse proxy directive; no public exploit identified at time of analysis. CVSS 3.1 base score 7.2 (High) reflects network reachability, low complexity, no privileges or user interaction, and changed scope impacting the proxied backend.
Arbitrary file write outside the intended extraction directory is possible in BusyBox's dpkg-deb applet because its ar archive handler flushes deferred symlinks after every archive member rather than once after the final member. A crafted .deb containing two data.tar members - the first declaring a symlink to an absolute path such as '/', the second declaring a regular file whose path traverses that now-live link - causes a file to be written at an attacker-chosen location when the package is unpacked (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-59). Affected systems are BusyBox builds compiled with dpkg-deb support, including BusyBox shipped inside Red Hat Hardened Images; the CVSS vector indicates no privileges are required by the attacker (PR:N) but the victim must interact by extracting the untrusted package, and the vector's local attack value plus the non-trivial two-member structure keep this a context-dependent integrity issue rather than a mass-exploitation emergency. No public exploit identified at time of analysis.
Heap-based buffer overflow in GStreamer's gst-plugins-base plugin library lets a local attacker who controls the sending side of a GStreamer inter-process IPC pipeline corrupt memory in the receiving process, yielding a CVSS 3.1 base score of 8.4 (AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) with high confidentiality, integrity, and availability impact. The victim process maps a crafted video buffer whose GstVideoMeta declares plane strides and offsets larger than the actual backing allocation, causing out-of-bounds reads and writes that can crash the process or potentially permit code execution in its context. Exploitation is strictly local and requires a deployment where GStreamer buffers cross a trust boundary between a less-trusted producer and a more-trusted consumer; no user interaction or authentication to the victim is needed, and no public exploit has been identified at time of analysis.
Use-after-free in curl's HTTP/2 client code (curl 8.12.0 through 8.22.0) can corrupt memory when a server answers an in-progress upload with an HTTP/2 RST_STREAM frame carrying the HTTP_1_1_REQUIRED or REFUSED_STREAM reason code, freeing the internal struct Curl_easy object while it is still referenced by the transfer state machine. The flaw is remote and requires no authentication (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, base 8.1), but exploitation is conditional: the victim must be uploading over a negotiated HTTP/2 connection to an endpoint the attacker controls or influences, and the RST_STREAM must land at the right point in the transfer lifecycle, which is why the assessed complexity is High. Publicly available exploit code exists (SSVC Exploitation: poc) and CISA's framework rates technical impact as total, yet there is no confirmed active exploitation (not in CISA KEV) and EPSS is low at 0.23% (12th percentile); a vendor patch is available. The same flaw affects libcurl and therefore every downstream application and distribution shipping an affected build.
Privilege escalation in the Ignition Perspective module (Inductive Automation Ignition) - a genuine high-priority issue in an OT/ICS context - allows an authenticated user with legitimate access to a Vision project to supply their valid Vision session identifier and obtain Designer-level privileges, leading to arbitrary code execution in the context of the Ignition Gateway process. The flaw (CWE-863, CVSS 8.7) affects Gateways where both Vision and Perspective modules are deployed, requires low-privilege Vision credentials and a valid session, and needs network reachability but no user interaction. No public exploit identified at time of analysis.
A use-after-free in Google Chrome's Media component lets a remote, unauthenticated attacker trigger memory corruption and execute arbitrary code inside the browser's renderer sandbox when a victim loads a crafted HTML page in any Chrome build prior to 155.0.8059.79. Exploitation is not confirmed in the wild - CISA's SSVC assessment lists exploitation as none and no public exploit code has been identified at time of analysis - and the EPSS score is low at 0.21% (10th percentile), although the technical impact if successfully triggered is total. User interaction is mandatory (UI:R), the attacker needs no credentials or privileges (PR:N), and Google has released a fixed build, so risk is serious but not emergency-grade.
Use-after-free in Google Chrome's Media component (versions prior to 155.0.8059.79) allows a remote, unauthenticated attacker to corrupt memory and execute arbitrary code inside the browser's renderer sandbox when a victim opens a crafted HTML page containing malicious media content (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, Chromium severity High). Successful exploitation requires only that the user navigate to the attacker-controlled page with an affected build; no credentials or non-default configuration are needed, so default desktop installations are exposed. No public exploit code has been identified at time of analysis, and CISA's SSVC assessment records exploitation as "none" with automatable "no," so this is a patch-promptly issue rather than an active emergency. Real-world impact is bounded by the fact that code execution stays within the sandboxed renderer process (scope unchanged, S:U); an attacker would need to chain a separate sandbox-escape flaw to reach the host operating system.
In-sandbox remote code execution is possible in Google Chrome builds prior to 155.0.8059.79 because of a use-after-free in the V8 JavaScript engine that is triggered when a victim loads a crafted HTML page. The issue carries a CVSS v3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and Google rates it High severity; no authentication or non-default configuration is required, but the attacker must induce a user to open the malicious page, and successful exploitation is confined to the browser sandbox, so full host compromise would also require a separate sandbox-escape flaw. No public exploit code and no active exploitation have been identified at time of analysis, and CISA's SSVC decision framework records Exploitation: none and Automatable: no, although the SSVC Technical Impact is rated total. A vendor patch (155.0.8059.79) is available.
Use-after-free in Chrome's V8 JavaScript engine allows remote, unauthenticated attackers to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page in Google Chrome builds prior to 155.0.8059.79. Exploitation is gated by user interaction (the victim must navigate to attacker-controlled HTML/JavaScript), and according to the CISA SSVC evaluation it is neither currently exploited nor assessed as automatable, with no public exploit identified at time of analysis. The SSVC technical impact is rated total within the affected component, but code execution is confined to the renderer sandbox - reaching the host operating system would require chaining a separate sandbox-escape vulnerability.
Arbitrary code execution inside the Chrome renderer sandbox is achievable through a use-after-free in the browser's Media component, affecting all desktop Chrome builds prior to 155.0.8059.79. An unauthenticated remote attacker can trigger the flaw by getting a victim to load a crafted HTML page; the CVSS vector requires user interaction (UI:R), so there is no zero-click path, and no public exploit has been identified at time of analysis. Impact is scoped to the renderer (S:U), meaning a successful exploit yields code execution within the sandbox rather than host compromise unless chained with a separate sandbox escape; Google classifies the issue as High severity and has shipped a fixed build.
Heap-based buffer overflow in Google Chrome's Animation component allows a remote attacker to execute arbitrary code inside the renderer sandbox by getting a victim to load a crafted HTML page in any build prior to 155.0.8059.79. The bug carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H): no authentication or special configuration is required, but exploitation depends on the user rendering attacker-controlled content, and because the scope is unchanged the resulting code execution is confined to the sandboxed renderer process rather than the host OS. No public exploit code and no confirmed active exploitation have been identified at time of analysis - CISA's SSVC evaluation rates Exploitation as 'none' - so this is a patch-promptly item rather than an emergency, with Google rating the issue High severity.
A use-after-free in the Core component of Google Chrome allows a remote attacker to potentially execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page. Affected builds are those prior to 155.0.8059.79, per the vendor advisory (EUVD's affected-version data lists the same 155.0.8059.79 threshold). Exploitation requires unauthenticated remote delivery with user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6) and is rated Critical by Chromium; there is no confirmed active exploitation (CISA SSVC Exploitation: none) and no public exploit identified at time of analysis, though the SSVC Technical Impact rating of "total" and the scope-changing (S:C) sandbox-escape impact make prompt patching important. Note a platform discrepancy: the description specifies Chrome on Android while the cited vendor reference is a desktop stable-channel update, so the exact affected platform should be confirmed against the advisory.
Use-after-free in the DOM component of Google Chrome prior to 155.0.8059.79 allows unauthenticated remote attackers to potentially execute arbitrary code inside the renderer sandbox by convincing a user to load a crafted HTML page (UI:R). With a CVSS score of 8.8, exploitation yields high confidentiality, integrity, and availability impact within the browser process, though full host compromise would require an additional sandbox escape not covered by this CVE. No public exploit code or active exploitation has been identified at time of analysis, and the vendor has released a patched version.
Use-after-free in Google Chrome's DOM implementation before 155.0.8059.79 allows unauthenticated remote attackers to execute arbitrary code inside the renderer sandbox when a victim navigates to a crafted HTML page. The flaw affects desktop stable and extended-stable channels and carries a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), with exploitation limited by the requirement for user interaction and by the renderer sandbox preventing direct host compromise without a separate sandbox escape. No public exploit identified at time of analysis, but a vendor patch is available.
Remote code execution confined to the renderer sandbox is possible in Google Chrome Desktop releases prior to 155.0.8059.79, where a use-after-free flaw in the Desktop component is triggered when a victim opens or is redirected to an attacker-controlled crafted HTML page. No authentication or special privileges are required (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, score 8.8), but exploitation depends on user interaction and the resulting code execution is limited to the sandboxed renderer unless a second, independent sandbox-escape vulnerability is chained. Vendor-released patch: 155.0.8059.79; there is no public exploit identified at time of analysis and CISA SSVC records no known exploitation, so this is a high-priority patch item rather than an emergency.
Use-after-free in Google Chrome's network component allows remote attackers to execute arbitrary code outside the sandbox by delivering crafted network traffic to versions prior to 155.0.8059.79. Exploitation requires a victim to interact with attacker-influenced content (UI:R) but no authentication (PR:N), and the vulnerability carries a CVSS score of 9.6 (Critical). Although no public exploit code or active exploitation has been identified at time of analysis, the severity and potential for full system compromise warrant immediate patching.
Sandbox escape in Google Chrome desktop builds prior to 155.0.8059.79 allows an attacker who can already run a program on the target host to abuse an incorrect authorization check in Chrome's Updater component and execute arbitrary code outside the browser sandbox, with high impact to confidentiality, integrity and availability plus a scope change across the sandbox boundary. The independent assessment scores this CVSS:3.1/AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H, meaning a pre-existing low-privileged local foothold and user interaction are both required, and CISA's SSVC rates the issue non-automatable, so opportunistic mass exploitation is unlikely. No public exploit code or confirmed active exploitation has been identified at time of analysis, and Google has shipped a vendor patch in Chrome 155.0.8059.79.
Sandbox escape through a use-after-free in Google Chrome's Passwords component allows an attacker who has already compromised the renderer process to execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page in versions prior to 155.0.8059.79. The flaw carries a high attack complexity (CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H, base 8.3) because the heap-timing condition must be reliably won, and it is not a standalone attack: it functions as the second stage of a chain, so no public exploit has been identified at time of analysis and CISA's SSVC assessment rates exploitation as 'none'. Vendor-released patch 155.0.8059.79 is available, which keeps opportunistic mass exploitation unlikely and points to targeted use only.
Use-after-free in SVG rendering in Google Chrome versions prior to 155.0.8059.79 allows a remote, unauthenticated attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page containing malicious SVG content (CVSS 3.1 base 8.8, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, CWE-416). Exploitation requires user interaction - the victim must navigate to attacker-controlled content - but no credentials or non-default configuration are needed, so default desktop installations are affected; the resulting code execution is confined to the renderer process, meaning full host compromise would additionally require a separate sandbox-escape bug. No public exploit code has been identified at time of analysis (CISA SSVC exploitation: none), and no public exploit identified at time of analysis; EPSS data was not provided. Google rates the issue Chromium security severity High and has released a stable-channel fix.
Sandbox escape in Google Chrome on macOS lets an attacker who has already compromised the renderer process execute arbitrary code outside the browser sandbox by delivering a crafted extension that abuses incorrect reference resolution in the Extensions subsystem, affecting all Mac builds prior to 155.0.8059.79. Google rates the issue High (Chromium severity: High) and has shipped a vendor fix, and there is no public exploit identified at time of analysis, with the CISA SSVC assessment recording exploitation as none. The impact is total once the chain fires (Scope:Changed, C:H/I:H/A:H), but high attack complexity (AC:H), required user interaction (UI:R) and the hard prerequisite of a prior renderer compromise make this a targeted second-stage escalation rather than a standalone remote exploit.
A heap-based buffer overflow in PDFium, the PDF rendering engine embedded in Google Chrome, allows a remote attacker to achieve arbitrary code execution inside the browser's renderer sandbox by convincing a victim to open a crafted HTML page. All desktop Chrome builds prior to 155.0.8059.79 (stable and extended-stable channels) are affected, and exploitation requires user interaction (UI:R), which limits mass or automated abuse. No public exploit code has been identified at time of analysis and CISA's SSVC assessment rates exploitation as none; however, CISA assigns a total technical impact once the bug is triggered, and Google rates the Chromium security severity as High. The primary constraint on real-world impact is that code execution is confined to the renderer sandbox, so full host compromise would additionally require chaining a separate sandbox-escape vulnerability.
Use-after-free in the Canvas rendering path of Google Chrome versions prior to 155.0.8059.79 allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page, requiring user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R, base 8.8). Because the freed object is reused in a graphics-rendering context, exploitation yields code execution only within the renderer sandbox, so full host compromise would require chaining a separate sandbox-escape flaw. No public exploit identified at time of analysis, and CISA's SSVC assessment rates exploitation as 'none' and automatable as 'no', though technical impact is rated 'total' if the bug is successfully triggered; a vendor-released patch (155.0.8059.79) is available.
A use-after-free in Google Chrome's Media component lets a remote, unauthenticated attacker who convinces a victim to load a crafted HTML page execute arbitrary code within the renderer sandbox (CVSS 3.1 base 8.8, vector AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). Only Chrome builds prior to 155.0.8059.79 are affected, and because the scope is unchanged (S:U) any meaningful escape from the browser sandbox would require chaining a separate sandbox-escape flaw. No public exploit code has been identified at time of analysis, CISA's SSVC assessment rates exploitation as none with automatable exploitation as no, and a vendor patch (155.0.8059.79) is available - the overall picture is a genuine, high-severity memory-corruption bug that nonetheless does not warrant top-tier emergency handling.
Heap buffer overflow in ANGLE, Chrome's graphics translation layer, allows a remote attacker to potentially execute arbitrary code outside the browser sandbox on Android. Chrome on Android builds prior to 155.0.8059.79 are affected, and the attack requires no authentication (PR:N) but does require the victim to render attacker-controlled web content (UI:R), with a CVSS base score of 9.6 and a scope change indicating sandbox-escape impact. No public exploit code has been identified at time of analysis, no CISA KEV entry exists, and SSVC rates exploitation as 'none' with automatable 'no', although technical impact is rated total and Google classifies the issue as Critical (Chromium security severity: Critical).
Remote code execution inside the Chrome renderer sandbox is possible via a use-after-free in the Media component of Google Chrome versions prior to 155.0.8059.79. An unauthenticated remote attacker can trigger the flaw by inducing a victim to load a crafted HTML page containing malicious media content; the CVSS vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) confirms that no privileges are needed but that user interaction is required, and that any code execution is confined to the renderer sandbox unless chained with a separate sandbox escape. Google rates the Chromium severity as Critical, a vendor patch in 155.0.8059.79 is available, and no public exploit code has been identified at time of analysis.
Use-after-free in the Chrome Browser process before version 155.0.8059.79 allows a remote attacker to execute arbitrary code outside the sandbox when a victim loads a crafted HTML page. Google rates this Chromium security severity Critical, and the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H, 9.6) reflects confirmed high confidentiality, integrity and availability impact with a sandbox-escape scope change; only user interaction - opening the malicious page - is required, and no authentication or prior access is needed. At the time of analysis there is no CISA KEV listing and no public exploit code identified, although weaponization of Chrome browser-process use-after-frees is a realistic near-term concern given the sandbox-escape payoff. Vendor patch: Google shipped a fix in the 155.0.8059.79 stable channel release.
Use-after-free in Google Chrome's SVG rendering path allows a remote, unauthenticated attacker to execute arbitrary code inside the renderer sandbox when a victim opens a crafted HTML page, affecting all desktop builds prior to 155.0.8059.79 on both the Stable and Extended Stable channels. Exploitation requires user interaction (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8), and because the scope is unchanged (S:U) the attacker gains renderer-process code execution, not host compromise, unless the primitive is chained with a separate sandbox escape. Chromium rates the flaw Critical, but all available exploitation signals are currently negative: CISA's SSVC assessment records Exploitation: none, and no public exploit code has been identified at time of analysis. Google has released a vendor patch in Chrome 155.0.8059.79.
Use-after-free in Google Chrome's built-in PDF handling lets a remote attacker achieve arbitrary code execution inside the browser sandbox by getting a victim to open a crafted HTML page containing malicious PDF content, affecting all desktop Chrome builds prior to 155.0.8059.79. Exploitation requires user interaction (UI:R) but no authentication (PR:N), and because the corrupted free happens in the renderer, code execution is contained by Chrome's sandbox - full host compromise would require chaining a separate sandbox-escape bug. CISA's SSVC assessment records no observed exploitation and no public exploit identified at time of analysis, so this is a genuine but not emergency-grade priority; Google rates the Chromium security severity as High and a vendor patch is available.
Use-after-free in Google Chrome's Passwords component (desktop stable builds prior to 155.0.8059.79) allows an attacker who has already compromised the renderer process to execute arbitrary code outside the browser sandbox by convincing a victim to load a crafted HTML page. The 8.3 CVSS score reflects high confidentiality, integrity, and availability impact with a changed scope, but it is unauthenticated on paper (PR:N) only in the sense that no credentials are checked - the real gate is the prerequisite renderer compromise plus a hard-to-win use-after-free race (AC:H) and required user interaction (UI:R). No public exploit code and no confirmed active exploitation (not in CISA KEV) were identified at time of analysis, and Google has already released a fixed build, so the signals point to lower real-world urgency than the raw score suggests.
Incorrect authorization in Chrome's Mojo IPC layer on Windows prior to 155.0.8059.79 allows a local attacker - a low-privileged user or code already running inside a Chrome child process - to escape the sandbox and execute arbitrary code with the browser's privileges; the flaw is a privilege boundary failure in the browser process, not a remote code-execution bug reachable by a web page alone. Exploitation requires a foothold on the Windows host: either a malicious local program or, in the more typical Chrome scenario, a compromised sandboxed renderer that chains this bug to break out. There is no public exploit identified at time of analysis and no CISA KEV listing, and a vendor patch is available; NVD's 9.6 score (AV:N/UI:R) overstates reachability compared with the independently assessed vector (AV:L/PR:L/UI:N), so the practical risk profile is a post-compromise sandbox escape rather than an unauthenticated network attack.
Use-after-free in Google Chrome's FileSystem component (CWE-416) lets an unauthenticated remote attacker execute arbitrary code outside the browser sandbox when a victim loads a crafted HTML page in any build prior to 155.0.8059.79. The 9.6 CVSS score is driven by the scope change (S:C) that models the sandbox escape plus high confidentiality, integrity and availability impact, yet exploitation requires mandatory user interaction (UI:R) and CISA's SSVC rates the attack non-automatable with exploitation status 'none', while Google itself assigns only Medium severity - sharply conflicting signals that should be reconciled before prioritization. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (CISA KEV).
Type confusion in the V8 JavaScript engine of Google Chrome allows remote attackers to achieve arbitrary code execution inside the renderer sandbox when a victim loads a crafted HTML page, affecting all builds prior to 155.0.8059.79. Exploitation requires no credentials (PR:N) but does require user interaction - the target must navigate to or be served attacker-controlled web content - and the resulting code execution remains confined to the renderer process, so a separate sandbox escape would be needed for host-level compromise. No public exploit code has been identified at time of analysis, there is no confirmed active exploitation (not in CISA KEV), and EPSS is low at 0.23% (13th percentile); Google has released a patched build and Chrome's automatic update mechanism shortens the practical exposure window.
Use-after-free in Google Chrome's Media component before version 155.0.8059.79 allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by convincing a user to open a crafted HTML page that drives the vulnerable media-parsing code path. Exploitation requires user interaction (the victim must navigate to or be redirected to attacker-controlled content), and the resulting code execution is confined to the sandbox, meaning host compromise would require chaining a separate sandbox-escape flaw. No public exploit code has been identified at time of analysis, EPSS is low (0.21%, 11th percentile), and Google has released a fixed build, so risk is serious but not emergency-level; priority should follow normal rapid-patching timelines.
Use-after-free in Google Chrome's ShapeDetection implementation, affecting all versions prior to 155.0.8059.79, allows an attacker who has already compromised the renderer process to execute arbitrary code outside the sandbox, turning a renderer foothold into full browser-process compromise. Exploitation is not standalone: the CVSS vector (AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H) and the assessed conditions require both a prior renderer compromise achieved through a separate bug and user interaction, since the victim must load attacker-controlled crafted HTML that exercises the ShapeDetection API to trigger the free-then-reuse condition. Exploitation status is limited: no public exploit identified at time of analysis, no CISA KEV listing, and EPSS is low at 0.21% (11th percentile), though the SSVC technical impact is rated total because success means code execution beyond the Chrome sandbox.
Google Chrome before 155.0.8059.79 contains a use-after-free in its WebRTC component that can let a remote, unauthenticated attacker execute code inside the renderer sandbox when a victim loads a crafted HTML page, requiring user interaction. The issue is high severity (CVSS 8.8, CWE-416) and has a vendor patch, but sandbox containment means host-level compromise would require a separate escape. No public exploit has been identified at time of analysis and EPSS is 0.21% (11th percentile), so active exploitation is not currently indicated.
Remote code execution outside the sandbox in Google Chrome allows an unauthenticated attacker to execute arbitrary code on a victim's system by convincing them to open a crafted HTML page that loads a malicious PDF, affecting Chrome versions prior to 155.0.8059.79 on all platforms. This is a use-after-free (CWE-416) in the PDF component with a Critical Chromium severity and an assessed CVSS of 9.6 (AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H). Exploitation requires user interaction, and no public exploit identified at time of analysis; EPSS is low at 0.21% (11th percentile), and the vendor has released a patch (155.0.8059.79).
Privilege elevation in Microsoft SQL Server lets an attacker who already holds high-privilege credentials on the instance trigger a stack-based buffer overflow over a network connection and break out of their authorization boundary. Exploitation is constrained: the CVSS vector (AV:N/AC:H/PR:H/UI:N/S:C) and the vendor description both indicate an authorized, highly privileged principal is required, and the AC:H rating means the overflow depends on specific server state, data, or timing rather than trivial input, so it is not reliably repeatable on a first attempt. All affected GDR and CU builds are pre-patch, Microsoft has published a fix via the MSRC update guide, and no public exploit or confirmed active exploitation was identified at time of analysis, so risk is real but conditional rather than a drop-everything emergency.
Command injection in MultiTail 7.1.5 and earlier lets an attacker who can write content into a monitored log or stream execute arbitrary shell commands as the user running MultiTail, because matched text is concatenated into a command passed to sh -c with only partial escaping. Exploitation is gated by a deliberate, non-default configuration: the operator must have enabled the -ex/-eX execute-on-match feature with a filter regex, and the injected line must match that regex; because the CVSS vector is AV:L/PR:L/UI:R, this is a local, low-privileged, user-interaction-dependent issue with impact bounded by the privileges of the MultiTail process. Exploitation code is publicly available (CISA SSVC reports Exploitation: poc), but there is no evidence of confirmed active exploitation, and the assessed risk is moderate and internally consistent rather than alarming.
Authentication bypass in Microsoft .NET allows an unauthenticated, remote attacker to forge a cryptographic signature and have it accepted by applications that rely on the framework's signature-verification routines, potentially leading to unauthorized access or token misuse. The JWT Attack tag points to a token-signature validation weakness; exploitation requires the target application or user to process the attacker-supplied signed token (UI:R), which limits reachability for purely passive endpoints. Affected versions include .NET 10.0 before 10.0.402, .NET 11.0 before 11.0.100-rc.2, and the listed Visual Studio 2022 17.14.x/2026 18.10.x builds; vendor patches are available, and no public exploit identified at time of analysis.
Code execution in .NET and Visual Studio can be triggered when a developer or user processes attacker-supplied content - such as a crafted project, build input, or dependency - that pulls functionality in from an untrusted control sphere and executes it. Affected builds are .NET 8.0 before 8.0.132, .NET 9.0 before 9.0.319, .NET 10.0 before 10.0.113, Visual Studio 2022 17.14 before 17.14.42, and Visual Studio 2026 18.10 before 18.10.4; the issue is network-reachable and unauthenticated (PR:N) but requires user interaction (UI:R) and non-trivial preconditions (AC:H), so an attacker cannot silently trigger it remotely. There is no public exploit identified at time of analysis and no confirmed active exploitation - the CISA SSVC exploitation value is 'none' - which keeps this a moderate-priority issue rather than a drop-everything emergency despite the 7.5 High CVSS score, especially since the SSVC technical impact is assessed as 'total' once exploitation conditions are met.
Unauthenticated remote denial of service in ASP.NET Core (8.0 before 8.0.32, 9.0 before 9.0.21, 10.0 before 10.0.13, and 11.0 before 11.0.0-rc.2) lets a network-reachable attacker exhaust resources because request processing is not adequately bounded or throttled, degrading or halting availability of hosted applications. Per the assessed CVSS:3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, exploitation requires no credentials, no user interaction, and no special configuration, but impact is confined to availability - no data disclosure or code execution results. No public exploit identified at time of analysis and SSVC records exploitation as none, though the flaw is rated automatable, meaning exploit tooling could be developed; patched framework builds and updated Visual Studio tooling are available from Microsoft.
An out-of-bounds write (CWE-787) in ASP.NET Core and the associated .NET runtimes lets a remote, unauthenticated attacker trigger memory corruption that crashes or destabilizes a network-reachable service, yielding a full loss of availability (CVSS 3.1 base 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H). Exploitation requires no credentials, no user interaction, and no special configuration - only that the target endpoint be reachable and running an unpatched build (for example .NET 8.0 below 8.0.32, .NET 9.0 below 9.0.21, or .NET 10.0 below 10.0.13). There is no public exploit identified at time of analysis and CISA's SSVC rates exploitation as "none" while marking the flaw fully automatable, so scripted denial-of-service attempts remain a plausible near-term risk; vendor patches are available.
Local privilege escalation in the .NET runtime (8.0, 9.0, 10.0, and 11.0 preview) and in Visual Studio 2022 17.14 and Visual Studio 2026 18.10, which ship affected runtime builds, allows an authenticated local attacker to gain higher-privileged file access or code execution by crafting a symbolic or hard link that a more privileged .NET or IDE process later resolves. Exploitation requires prior low-privileged local access to the host and typically depends on winning a timing/race condition against a privileged process (CISA SSVC Automatable: no), which confines realistic risk to developer workstations, build servers, and CI agents rather than general end-user endpoints. The issue scores 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) with total technical impact, no public exploit has been identified at time of analysis, and vendor-released patches are available. This is a credible but not emergency-grade issue, best treated as routine-high patching priority rather than a drop-everything event.
Cross-site scripting (CWE-79) in the ASP.NET Core Blazor WebAssembly Server hosting component allows an unauthenticated, network-based attacker to execute arbitrary script in a victim's browser session by getting attacker-influenced input rendered into a web page without proper HTML neutralization. Affected are applications built on Microsoft.AspNetCore.Components.WebAssembly.Server 10.0.0 through <10.0.13, as well as apps produced by the vulnerable Microsoft Visual Studio 2026 18.10.x (<18.10.4) and Visual Studio 2022 17.14.x (<17.14.42) toolchains. Exploitation is not automatable per CISA SSVC and requires mandatory user interaction (CVSS UI:R) - the victim must load or interact with the crafted content - and no public exploit code or active exploitation has been identified at time of analysis; vendor patches are available, so risk is primarily to unpatched, internet-facing Blazor WebAssembly deployments.
Local privilege escalation in Microsoft .NET (CWE-59 link following) lets an authenticated attacker with existing low-privileged code execution escalate to higher privileges by creating symbolic links or junctions and winning a link-resolution race against a privileged .NET file operation. Affected builds include .NET 8.0 before 8.0.32, 9.0 before 9.0.21, 10.0 before 10.0.13, 11.0 before 11.0.0-rc.2, Microsoft Visual Studio 2022 17.14 before 17.14.42, and Microsoft Visual Studio 2026 18.10 before 18.10.4. No public exploit code was identified at time of analysis, and CISA SSVC rates exploitation as none, so this is a post-compromise escalation primitive rather than an initial-access vector; vendor patches are available.