Code injection in dataclasses-avroschema versions 0.38.0 through 0.70.5 allows remote, unauthenticated attackers who supply a crafted Avro schema to inject constrained Python statements into the module produced by the schema-to-code generator; the injected code executes when that generated module is imported. Exploitation requires the victim to deliberately process an untrusted schema through the avro-to-code path and then import the resulting module (the UI:R gate), which limits exposure to pipelines that ingest third-party schemas. CVSS 3.1 base score is 8.8 (High) with vector AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H; no public exploit identified at time of analysis, and version 0.70.6 fixes the flaw by validating enum defaults as names.
Code injection in dataclasses-avroschema versions 0.38.0 through 0.70.5 lets an attacker who controls the Avro schema consumed by the library's model-generator classes inject arbitrary statements into the generated Python source, because enum symbols are used as generated enum member names after case conversion without being validated as Python identifiers. Exploitation is not on the library's default runtime serialization path: it requires an application to invoke the generator classes directly (BaseGenerator.parse_enum / EnumRepresentation.render_symbols) on an attacker-supplied schema and then import or execute the emitted module, which is why the assessed vector carries UI:R despite being network-reachable and unauthenticated (PR:N). Impact when the chain is completed is code execution and namespace modification in the importing process with high confidentiality, integrity, and availability consequences (CVSS 8.8); no confirmed active exploitation (CISA KEV) and no public exploit code identified at time of analysis. Version 0.70.6 fixes the issue by validating every enum symbol as a name.
Python code injection in dataclasses-avroschema versions 0.38.0 through 0.70.5 lets an attacker with control over Avro schema content smuggle arbitrary Python statements into the enum class body that the library emits, so simply importing the generated module executes the attacker's code. The flaw sits in EnumRepresentation.render_symbols, which wraps each schema-supplied enum symbol in double quotes without escaping it, allowing a quote character to close the literal and append attacker-chosen Python. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8, CWE-94) indicates no privileges are required but that user interaction is essential, since the victim must run the import of the generated file; no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, and version 0.70.6 fixes it by escaping enum symbol values before rendering.
Stored cross-site scripting (XSS) in Adobe Commerce, Adobe Commerce B2B, and Magento Open Source allows an authenticated low-privileged attacker to inject malicious JavaScript into vulnerable form fields, which then executes in a victim's browser when they view the affected page. The flaw carries a vendor CVSS 3.1 score of 8.7 (CWE-79) and requires victim interaction; no public exploit or active exploitation is identified at time of analysis. Successful exploitation can lead to theft of session tokens or account manipulation for the victim user.
Authenticated users with workflow create/edit rights on self-hosted Heym deployments prior to 0.0.40 can escape the application's blacklist-based Python sandbox and execute arbitrary commands and file operations as the backend service account. The flaw lives in backend/app/services/python_tool_executor.py, where the allowlisted standard-library modules still expose OS, process, and filesystem primitives through public attributes, so tool source that passes _safe_import() and _validate_code_safety() is ultimately run through exec() with full application privileges (CVSS 8.8, CWE-78). Exploitation requires a low-privilege authenticated account (PR:L) with permission to create or edit a workflow containing an Agent custom Python tool; enabling self-registration makes that account trivially obtainable, though merely triggering a workflow from the portal does not grant code control. There is no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV), but the fix in 0.0.40 is available and the assessed risk is high for any multi-user deployment.
Arbitrary code execution in Adobe Commerce, Adobe Commerce B2B, and Magento Open Source is reachable by an attacker who already holds a high-privilege administrator-level account, exploiting an improperly validated input path to run code in the context of the current user with no victim interaction required. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H) rates confidentiality, integrity, and availability impact as high with a changed scope, meaning the effect is not contained within the vulnerable component; the governing limitation is the PR:H precondition, which keeps the realistic attacker set to insiders, holders of compromised admin credentials, or post-authentication attack chains rather than anonymous or low-privileged users. No public exploit code was identified and there is no confirmed active exploitation (CISA KEV) at time of analysis, so this should be treated as a high-value post-authentication target rather than an opportunistically exploited one.
SQL injection in SAP Commerce Cloud lets an authenticated user with only low-level privileges (CVSS 8.8, AV:N/AC:L/PR:L/UI:N) inject arbitrary SQL through specially crafted requests into the affected out-of-the-box functionality, with the potential to read, modify or delete sensitive application database data and therefore high confidentiality, integrity and availability impact. The flaw is CWE-89 in code delivered as part of SAP Commerce Cloud itself, meaning it is not confined to a customer's custom extensions, but the advisory does not name the exact endpoint or parameter, so the precise injectable surface is not confirmed from available data. No public exploit code and no confirmed active exploitation were identified at time of analysis; the only real precondition is obtaining a valid authenticated session, which is a low barrier for deployments that allow customer self-registration or maintain numerous back-office accounts. This is a genuine high-priority vulnerability, though not an emergency.
Arbitrary code execution in dataclasses-avroschema versions 0.38.0 through 0.70.5, where BaseGenerator.parse_fixed writes a fixed type's 'aliases' value straight into the generated types.confixed annotation: a bare string alias (instead of a JSON list) is emitted as an unquoted Python expression and evaluated the moment the generated module is imported. Exploitation is not automatic - it requires a developer to run the library's Avro-schema-to-Python code generation over an attacker-influenced schema and then import the resulting module, which is why the vector carries UI:R despite PR:N and network-level delivery of the malicious schema. The flaw is a genuine CWE-94 code-injection issue with high confidentiality, integrity and availability impact under our assessed CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H; no public exploit code has been identified at time of analysis and it is not in CISA KEV. Version 0.70.6 fixes it by rejecting any 'aliases' value that is not a list.
Code injection in dataclasses-avroschema 0.38.0 through 0.70.5 lets an attacker-influenced Avro schema execute arbitrary Python when the library's model generator renders a 'fixed' type's namespace into generated source. BaseGenerator.parse_fixed interpolates the namespace between quotes inside a generated types.confixed annotation without escaping, so a namespace containing a quote character terminates the string literal and turns the remainder into live Python that runs when the generated class is defined or the generated module is imported; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (8.8), unauthenticated over the network but requiring the victim to run code generation on the crafted schema and then import the result. The flaw is fixed in 0.70.6, which enforces that namespaces are dot-separated sequences of valid Avro names; no public exploit code was identified at time of analysis and the issue is not in CISA KEV, but the high CVSS score, confirmed GHSA-h9q3-f96w-f88j advisory, and availability of a vendor fix commit make prompt upgrading advisable for anyone generating code from externally sourced schemas.
Code injection in dataclasses-avroschema versions 0.40.0 through 0.70.5 lets an attacker who controls the `doc` value of an Avro schema record close the generated class docstring and inject arbitrary Python statements into the emitted class body, achieving code execution when the generated module is imported. The CVSS vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8) rates the flaw as network-reachable, low-complexity and unauthenticated with high confidentiality and integrity impact, but exploitation is gated by user interaction: a developer or CI pipeline must both run the library's model generator against the attacker-influenced schema and import the resulting Python file. No public exploit code has been identified at time of analysis, and the vendor released a fix in 0.70.6.
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.
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.
Local privilege escalation in Microsoft Defender for Endpoint allows an authenticated attacker who already holds low-privileged code execution on the host to elevate to a higher-privileged context by planting a symbolic link, NTFS junction, or hardlink at a filesystem path that Defender's privileged components later resolve and follow (CWE-59). The prerequisite is a local, authenticated foothold (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8); no user interaction is required, and no special Defender configuration is implied, so default deployments are likely in scope. There is no public exploit code and no confirmed active exploitation at time of analysis, and this is assessed as a credible but not emergency-tier priority given that the flaw cannot be used for initial remote access and is bounded to the local machine.
Local privilege elevation in Microsoft Hyper-V allows a low-privileged, authenticated attacker on a Hyper-V-enabled Windows 10, Windows 11, or Windows Server host to exploit an out-of-bounds read and gain elevated privileges. The CVSS 8.8 score reflects local access, no user interaction, scope change, and high confidentiality, integrity, and availability impact, but exploitation requires an existing local foothold and active Hyper-V. No public exploit has been identified at time of analysis, EPSS is 0.33%, and CISA SSVC records exploitation as none and automatable as no.
Local privilege escalation in the Microsoft Windows Virtualization-Based Security (VBS) Enclave allows an authenticated attacker who already holds low privileges on an affected host to execute against higher-integrity code inside the isolated secure environment, achieving elevated privileges locally. The defect is an untrusted pointer dereference (CWE-822) in the enclave interface, and because the code runs inside a security boundary the CVSS assessment is scope-changed (S:C) with high confidentiality, integrity and availability impact (CVSS 8.8, AV:L/AC:L/PR:L/UI:N). No public exploit code has been identified at time of analysis, CISA's SSVC decision framework records exploitation as 'none' and automatable as 'no', and a vendor patch is available, so this is a genuine but non-emergency priority that matters chiefly as a post-compromise escalation primitive on hosts where VBS is deployed.
Code execution that crosses the guest-to-host boundary in Microsoft Windows Hyper-V can be triggered by an authenticated, low-privileged attacker who already runs code inside a guest virtual machine, letting them escape the VM and affect the host partition. The weakness is an access-control flaw in the hypervisor (CVSS 3.1 base 8.8, AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), so it is a local privilege and tenancy escape rather than a remotely reachable path, and a guest foothold is a hard prerequisite. No public exploit has been identified at time of analysis, but the risk is concentrated on hosts running untrusted, multi-tenant, or otherwise attacker-reachable guests.
Use-after-free memory corruption in Windows Hyper-V allows an authenticated low-privileged attacker who already has code execution inside a guest VM to trigger memory corruption in the hypervisor and, per the assessed scope change, likely cross the guest-to-host boundary with high confidentiality, integrity, and availability impact. The CVSS:3.1 vector is AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, so the flaw is local, low-complexity, requires low privileges, needs no user interaction, and has Changed scope; it is not a remote unauthenticated network-reachable bug. Exploitation status: no public exploit identified at time of analysis, and no CISA KEV active-exploitation entry was provided.
Local privilege escalation in Microsoft Office Click-To-Run allows an authenticated low-privileged attacker who already has code execution on a target host to trigger a use-after-free (CWE-416) and gain elevated privileges. The flaw affects Microsoft 365 Apps for Enterprise and Office LTSC 2021/2024 installations, requires no user interaction, and has no remote attack surface; no public exploit has been identified at time of analysis. CISA SSVC rates exploitation as none and automatable as no, and vendor patches are available.
Privilege escalation in Leantime prior to 3.10.0 allows an authenticated low-privilege user to create a full administrator account, or to install, enable, disable and remove plugins, by calling methods exposed through the application's JSON-RPC dispatcher. Any user holding a valid ordinary browser session can trigger this by sending the required X-Requested-With: XMLHttpRequest header and invoking leantime.rpc.api.api.createApiKeyWithProjects with an attacker-chosen role, because PermissionEnforcer::enforce treats API service methods that lack a RequiresPermission attribute as public; exposure widens significantly on installations where open or self-service registration is enabled, since obtaining the prerequisite low-privilege session becomes trivial. There is no public exploit identified at time of analysis and the issue is not listed in CISA KEV, but the CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects complete compromise of confidentiality, integrity and availability once the privilege boundary is crossed, and the vendor has shipped a fix in version 3.10.0.
Authenticated low-privileged users can exploit an SQL injection flaw in Fortinet FortiAnalyzer and FortiAnalyzer Cloud to execute arbitrary commands on the underlying system. The vulnerability affects FortiAnalyzer 7.6.0-7.6.4, 7.4.0-7.4.7, and all 7.2 versions, as well as FortiAnalyzer Cloud 7.6.2-7.6.4, 7.4.1-7.4.7, and 7.2.1-7.2.11. The CVSS 3.1 score is 8.8 (High) with a vector requiring network access and low privileges; no public exploit code has been identified at time of analysis.
A heap-based buffer overflow in the Windows PCI Bus Driver lets an authenticated local attacker with only low privileges escalate to kernel-level code execution on affected Windows hosts, giving total loss of confidentiality, integrity, and availability (CVSS 8.8, scope-changed). Exploitation requires an existing low-privilege local session (AV:L/PR:L, UI:N) and the ability to invoke the driver with malformed input - there is no remote or network path, and CISA's SSVC assessment rates the issue as not automatable with exploitation: none. No public exploit code has been identified at time of analysis and there are no reports of active exploitation, but the driver is a default, always-present kernel component on every supported Windows client and server build, so the vulnerable surface is ubiquitous and the payload is high-impact once a foothold exists - making this a credible but non-urgent prioritization.
Local privilege escalation in the Windows UI Immersive Server component allows an attacker who already holds a low-privileged local account on a Windows host to corrupt heap memory via a crafted input and elevate to a higher-integrity context, including SYSTEM. Affected systems are all supported Windows client and server editions running builds below the fixed patch level, ranging from Windows 10 1607 and Windows Server 2012 up through Windows 11 26H2 and Windows Server 2025; patched builds are not exploitable, and there is no remote or unauthenticated path. There is no public exploit identified at time of analysis, CISA's SSVC rates exploitation as none and non-automatable, and no EPSS score was supplied, so the practical risk is a serious but post-compromise local escalation flaw rather than an emergency-grade, mass-exploitable issue; a vendor patch is available.
Heap-based buffer overflow in Microsoft Hyper-V (CVE-2026-83716, CVSSv3.1 8.8) lets an authenticated attacker who already holds low-privileged access inside a guest VM corrupt hypervisor heap memory and execute code on the Windows host, crossing the virtualization boundary (Scope: Changed). Exploitation requires the Hyper-V role to be enabled and a guest foothold (AV:L/PR:L), with no user interaction and low attack complexity, but there is no remote or network-facing attack surface, and no public exploit code or confirmed active exploitation has been identified at time of analysis. Microsoft has released patched builds for the affected Windows 10, Windows 11 and Windows Server 2016 through 2025 versions, making this a credible high-priority patch target rather than an emergency.
Authenticated SQL injection in Fortinet FortiMail versions 7.6.0 through 7.6.3, 7.4.0 through 7.4.5, and 7.2.0 through 7.2.8 allows an attacker with a low-privilege account to execute unauthorized code or commands via crafted HTTP/HTTPS requests to the management or webmail interface. The vulnerability requires network reachability and a valid session (PR:L) but no user interaction, with low attack complexity. No public exploit has been identified at time of analysis, but the high CVSS score (8.8) and potential for full compromise of confidentiality, integrity, and availability make it a credible priority for operators, especially if the interface is internet-facing.
Local privilege escalation in the Windows Bind Filter Driver (bindflt) allows an authenticated, low-privileged user on Windows 11 Version 23H2 and Windows Server 2025 (including Server Core) to gain full control of the affected host, including the ability to read and modify protected data and execute code at kernel/SYSTEM level. The flaw is an improper access control weakness (CWE-863) in a driver that is present by default, requiring only that the attacker already hold a local session on the machine; no user interaction is needed and the scope is changed because escaping the sandbox of a normal user account compromises the entire OS. Microsoft has released fixes, and there is no public exploit identified at time of analysis; CISA's SSVC assessment rates the issue non-automatable, so it is a credible, high-priority local escalation risk rather than an opportunistic mass-exploitation threat.
Arbitrary Python code execution in dataclasses-avroschema versions 0.44.0 through 0.70.5 occurs because the Pydantic and AvroDantic model generators embed an Avro schema field's pydantic-class value directly into a generated field annotation after the literal prefix 'pydantic.', without sanitizing the expression. When a victim runs the code-generation path (ModelGenerator) on an attacker-influenced schema and then imports the generated Python module, the injected annotation is evaluated at import time and the payload executes with the privileges of that process, giving full confidentiality and integrity impact (CVSS 8.8, AV:C:N/AC:L/PR:N/UI:R). Exploitation is unauthenticated from the network perspective (CVSS PR:N) but requires the victim to generate and import the code, and no public exploit code or CISA KEV entry was identified at time of analysis; version 0.70.6 restricts the value to a bare name or a call to a bare name with literal arguments.
Code injection in dataclasses-avroschema 0.38.0 through 0.70.5 allows an attacker who supplies a crafted Avro schema to the library's Avro-to-Python code generator (model_generator) to embed arbitrary Python statements into the generated module via an enum field default, and those statements execute when the generated module is imported, either modifying the module namespace or preventing it from loading (CVSS 3.1 8.8, CWE-94). The CVSS vector (AV:N/AC:L/PR:N/UI:R) indicates the flaw is unauthenticated but requires user interaction: a victim must run the generator against the attacker-controlled schema and then import the resulting module, so environments that only generate code from their own trusted models or never load attacker-influenced generated code are not exposed. The maintainer confirmed and patched the issue in 0.70.6 by validating enum defaults as names; no public exploit code has been identified at time of analysis, and no active exploitation is confirmed (CISA KEV) at the time of writing.
Local privilege escalation in the Windows AppX Deployment Extensions component allows an authenticated, low-privileged attacker who already has code execution or interactive access on a host to elevate to a higher-integrity context, including SYSTEM, because a required authorization check is missing (CWE-862). The flaw carries a CVSS 3.1 base score of 8.8 from the vector AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H - the Scope:Changed rating reflects that a successful exploit crosses a privilege boundary, granting high confidentiality, integrity, and availability impact. Every supported Windows client and server release is exposed, and because the component ships in default Windows installations, no unusual configuration is required once the attacker has a foothold; there is no KEV listing and no public exploit identified at time of analysis, though the low attack complexity and absence of user interaction make it an attractive post-compromise escalation primitive. Microsoft has released fixed builds, so this is a genuine prioritization candidate for patch cycles rather than an unmitigable emergency, but the hard prerequisite of existing local access is the main constraint on real-world risk.
Windows PowerShell on supported Windows client and server editions fails to enforce a protection mechanism, letting a locally authenticated low-privileged attacker bypass a security feature and operate outside the intended security boundary, achieving high confidentiality, integrity, and availability impact (CVSS 8.8, scope-changed). Exploitation requires a pre-existing local foothold and the ability to run PowerShell on the host - there is no remote or unauthenticated path, and CISA's SSVC assessment rates exploitation as 'none' with Automatable=no, meaning the issue is not wormable or easily mass-scanned. There is no public exploit identified at time of analysis, though the technical impact is rated total once the prerequisite access is obtained; Microsoft has released fixes and the MSRC update guide is the authoritative remediation source.
Unauthenticated modification of the embedded webserver password on Rockwell Automation 1732E ArmorBlock I/O modules allows any network-reachable attacker to seize the administrative account and alter device configuration. The flaw is rated 8.8 (CVSS 4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VI:H/VA:H, no confidentiality impact), matching an authentication-bypass class (CWE-294) and confirmed by the independent assessment as CVSS:3.1 AV:N/AC:L/PR:N/UI:N with C:N/I:H/A:H. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, and real-world exposure depends on whether the module's webserver is reachable from untrusted networks rather than being contained by OT segmentation.
Local privilege escalation in the Windows Virtualization-Based Security (VBS) Enclave allows an authenticated attacker who already holds low-privileged code execution on a VBS-enabled host to cross the enclave trust boundary and gain high-integrity code execution, carrying a CVSS 3.1 base score of 8.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H). Patched builds are absent across Windows 10 (1607 through 22H2), Windows 11 (23H2 through 26H2), and Windows Server 2016 through 2025, including Server Core installations. No public exploit code or confirmed active exploitation has been identified at time of analysis, with CISA's SSVC assessment recording exploitation as none and automatable as no.
Improper input validation in Microsoft Windows Hyper-V allows an authenticated but low-privileged local user to spoof trusted resources on a virtualization host, tampering with data that should be integrity-protected (CISA SSVC 'Technical Impact: total'; CVSS 8.8 HIGH). Exploitation is strictly local (AV:L) and requires a valid low-privileged account (PR:L) plus the Hyper-V role or hypervisor platform to be present, with no user interaction; CISA's SSVC records no observed exploitation and rates the flaw non-automatable, so no public exploit code has been identified at the time of analysis. Microsoft has shipped fixed builds across all affected Windows 10, Windows 11 and Windows Server 2012-through-2025 SKUs, including Server Core installations.
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.
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.
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.
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 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.
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.
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 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 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.
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.
Authenticated path traversal in Omnispace Agora Project before 26.10.0 lets a low-privileged user write attacker-controlled files outside the intended upload temporary directory by supplying an unanchored tmpFolderName value in the upload destination path; pointing it at the web root can yield remote code execution if the written file is executable from that location. Per the CVSS vector (PR:L), a valid low-privileged account on the Agora web application is required, so exposure is materially lower on instances with restricted account provisioning or closed self-registration, and versions 26.10.0 and later are unaffected. CVSS 8.7 (v4.0) reflects high confidentiality, integrity and availability impact; no public exploit code or confirmed active exploitation was identified at time of analysis, and a vendor patch (26.10.0) is available.
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.