Remote Code Execution

Remote code execution in Google Chrome desktop versions prior to 151.0.7922.72 lets a remote attacker run arbitrary code within the browser's renderer sandbox by luring a victim to a crafted HTML page that triggers an integer overflow in the bundled libxml component. Google rated the flaw High severity and a vendor patch is available; there is no public exploit identified at time of analysis, and the low EPSS score (0.35%) alongside CISA SSVC 'Exploitation: none' indicates no observed exploitation yet. Because the bug is contained to the sandboxed renderer, a successful attacker would still need a separate sandbox-escape to reach the host.

Remote code execution in Google Chrome desktop versions prior to 151.0.7922.72 arises from a use-after-free in the DOM implementation, letting a remote attacker who lures a victim to a crafted HTML page run arbitrary code within the renderer sandbox. The flaw was reported internally by the Chrome team, rated High by Chromium, and carries CVSS 8.8; there is no public exploit identified at time of analysis and EPSS is low at 0.35% (28th percentile). Because execution is confined to the sandbox (Scope: Unchanged), full host compromise would additionally require a separate sandbox-escape chain.

Remote code execution in Google Chrome desktop before 151.0.7922.72 stems from a use-after-free in the Autofill component, letting a remote attacker who lures a victim to a crafted HTML page run arbitrary code within the renderer sandbox. Rated High by Chromium and CVSS 8.8, it requires user interaction (visiting a malicious page) but no authentication. No public exploit identified at time of analysis, and EPSS is low (0.35%, 28th percentile), consistent with a freshly patched browser bug not yet weaponized.

Remote code execution in Google Chrome's V8 JavaScript engine (versions prior to 151.0.7922.72) allows a remote attacker to run arbitrary code inside the renderer sandbox when a victim opens a crafted HTML page. The flaw is a use-after-free (CWE-416) rated High by Chromium with a CVSS of 8.8, but there is no public exploit identified at time of analysis, EPSS is low (0.35%, 28th percentile), and CISA SSVC marks exploitation as none. Because code execution is confined to the sandbox, full host compromise would require chaining with a separate sandbox-escape.

Remote code execution in Google Chrome's Loader component before 151.0.7922.72 allows a remote attacker to execute arbitrary code inside the browser's renderer sandbox by luring a victim to a crafted HTML page (CWE-416 use-after-free). The flaw carries a High Chromium severity and CVSS 8.8, but code execution is confined to the sandbox and requires user interaction (visiting the page); a full-system compromise would need an additional sandbox-escape bug. No public exploit identified at time of analysis, and EPSS is low at 0.35% (28th percentile).

Remote code execution in Google Chrome's V8 JavaScript engine (versions prior to 151.0.7922.72) allows a remote attacker to run arbitrary code within the browser's renderer sandbox by luring a victim to a crafted HTML page. The flaw is a use-after-free (CWE-416) rated High by Chromium and CVSS 8.8, requiring user interaction (visiting a page) but no authentication. There is no public exploit identified at time of analysis and EPSS is low (0.35%, 28th percentile), consistent with a freshly patched, vendor-reported bug rather than one under active exploitation.

OS command injection in dnsmgr version 2.15 and earlier lets an attacker execute arbitrary commands through the ping function in CheckUils.php, which passes unsanitized input into a system shell call (CWE-77). SSVC rates the technical impact as total and marks exploitation as proof-of-concept, so publicly available exploit code exists, though it is not on CISA KEV and EPSS is low (0.15%). The published CVSS is 9.8, but note the description characterizes the attacker as 'local' while the CVSS vector encodes AV:N - this discrepancy affects real-world exposure and should be resolved against the target deployment.

Heap-based buffer overflow in schreibfaul1's ESP32-audioI2S library version 3.4.5 lets an attacker who controls audio stream metadata corrupt heap memory through the latinToUTF8() character-encoding routine, with SSVC rating the technical impact as total (potential code execution, information disclosure, DoS or privilege escalation). The flaw is demonstrated by publicly available exploit code but is not listed in CISA KEV, so it reflects a POC-stage issue rather than confirmed active exploitation. The library is a widely-used hobbyist Arduino/ESP32 audio component, so exposure is concentrated in embedded maker and IoT projects rather than enterprise fleets.

Arbitrary file read and remote code execution in Ruby on Rails Active Storage's libvips-based variant processor allows unauthenticated remote attackers to upload a crafted file and invoke unsafe libvips 'unfuzzed' operations, disclosing arbitrary server files including process environment variables that typically contain secret_key_base and external service credentials. Applications using the libvips variant processor (the default since load_defaults 7.0) that accept image uploads from untrusted users across activestorage versions below 7.2.3.2, 8.0.5.1, and 8.1.3.1 are affected. No public exploit code has been released at disclosure time (July 30, 2026), but independent researchers from Ethiack and GMO Flatt Security assess that AI-assisted POC development is feasible within hours, making immediate patching critical.

Remote code execution in Autel MaxiCharger AC Elite Home EV chargers allows unauthenticated network attackers to run arbitrary code on the device by exploiting an integer underflow in the OCPP WebSocket message handler. The flaw stems from missing validation of user-supplied length/size data used in a buffer allocation, giving full compromise of the charger. There is no public exploit identified at time of analysis, and the issue is not listed in CISA KEV; it was reported privately through Zero Day Initiative (ZDI-26-437 / ZDI-CAN-29113).

Local privilege escalation in MSI Center's bundled NTIOLib_X64.sys kernel driver lets a low-privileged user execute arbitrary code as SYSTEM by issuing commands the driver fails to properly authenticate. The flaw (ZDI-CAN-28935 / ZDI-26-430) stems from the driver not validating the origin of incoming commands, so any local process can drive its privileged I/O primitives. There is no public exploit identified at time of analysis and it is not on CISA KEV, but ZDI's disclosure and the NTIOLib family's history of abuse make weaponization plausible.

Local privilege escalation in G DATA Total Security lets a low-privileged user abuse the Backup Service to delete an arbitrary file via a symbolic link (CWE-59 link following), which can be leveraged to run arbitrary code as NT AUTHORITY\SYSTEM. Discovered and reported through the Zero Day Initiative (ZDI-26-432, ZDI-CAN-28665); there is no public exploit identified at time of analysis and it is not listed in CISA KEV. The vendor-assigned CVSS 3.0 base score is 7.8 (High), reflecting full SYSTEM-level compromise achievable by any authenticated local user.

Remote code execution in Heimdall Data Database Proxy lets an authenticated, high-privileged attacker inject CRLF sequences into the generateFileContent function to run arbitrary commands as root (ZDI-26-447, formerly ZDI-CAN-29251). The flaw carries a CVSS 7.2 (PR:H) rating and was reported through the Zero Day Initiative; no public exploit identified at time of analysis and it is not on CISA KEV, so exploitation risk is currently theoretical but the root-level impact is severe.

Out-of-bounds write in the pgvector PostgreSQL extension (versions before 0.8.6) lets an authenticated database user trigger an integer wraparound during IVFFlat index construction, corrupting heap memory in the backend process and potentially achieving arbitrary code execution. The flaw is exploitable only on 32-bit systems, where size calculations in the k-means clustering routine overflow the Size type. There is no public exploit identified at time of analysis and it is not listed in CISA KEV.

Remote code execution and denial-of-service in the TP-Link TL-WR940N v6 router stem from a stack-based buffer overflow in the kernel-resident RTSP connection-tracking (ALG) module. An attacker who lures a LAN-side client into connecting to an attacker-controlled RTSP server can send a crafted RTSP message that the router's kernel helper mishandles, potentially yielding full device compromise. The flaw is exploitable by an unauthenticated attacker against the router's default configuration; no public exploit has been identified at time of analysis, and the issue is not listed in CISA KEV.

Arbitrary code execution and denial of service in BlackBerry QNX Software Development Platform arises from the traceparser library (libtraceparser), where the decode() function fails to properly validate input from kernel trace event log (.kev) files. A local attacker who supplies a maliciously corrupted .kev file can crash - or potentially run code within - any host or target process that parses it with libtraceparser. Reported by BlackBerry with no public exploit identified at time of analysis; the CVSS 7.0 (AC:H, UI:R) reflects that exploitation requires a victim to process the attacker's crafted file.

Remote code execution in Care Everywhere Gateway 14.3.10 stems from hard-coded, install-invariant credentials in its bundled WildFly 8.2.0.Final management interface (port 20990), letting unauthenticated remote attackers log into the management console and deploy a malicious WAR to run code as the Windows machine account. The affected 14.x branch reached end-of-life in 2017 and later releases remediate the issue. Publicly available exploit code exists (VulnCheck), and given AV:N/AC:L/PR:N/UI:N the barrier to exploitation is minimal, though this is not listed in CISA KEV.

Remote code execution in Xlight FTP Server versions before 3.9.5 allows unauthenticated attackers to corrupt stack memory by sending malformed SSH packets once an AES-GCM cipher is negotiated during the SSH/SFTP handshake. An unvalidated length field is passed directly to the GCM decrypt routine, overwriting the stack cookie and saved return address before any authentication occurs, potentially yielding code execution as the FTP service. Reported by VulnCheck; no public exploit has been identified at time of analysis, but the pre-auth, network-reachable nature makes it a high priority.

Arbitrary code execution in Autodesk AutoCAD, AutoCAD LT, and DWG TrueView occurs when a user opens a maliciously crafted DXF file, triggering a heap-based buffer overflow (CWE-122) in the file parser. A local attacker who convinces a victim to open the file can crash the application, read sensitive in-process memory, or run code in the context of the current user. There is no public exploit identified at time of analysis, and the file-format vector plus required user interaction places this in the classic 'malicious drawing file' threat model rather than remote mass exploitation.

Arbitrary code execution in swagger-typescript-api (npm, versions <= 13.12.1) lets an attacker who controls an OpenAPI spec inject JavaScript that runs at module load in whoever generates and imports the client. Because the generator's Ts.StringValue helper wraps enum strings in double quotes with zero escaping, a crafted components.schemas.*.enum value breaks out of the generated TypeScript enum and plants a bare-block async IIFE that fires on a mere import - no HttpClient instantiation or API call needed. Publicly available exploit code exists (self-contained reproducer in advisory GHSA-5f94-x226-ccpm), but there is no active exploitation confirmed and it is not in CISA KEV; the fix landed in 13.12.2.

Arbitrary code execution in swagger-typescript-api (npm) versions <= 13.12.1 arises when the generator emits an axios HTTP client from an attacker-controlled OpenAPI spec: the unescaped `servers[0].url` is interpolated raw into the `axios.create({...})` call inside the generated `HttpClient` constructor, letting a crafted URL break out of the string literal and inject a computed-property-key IIFE that runs on every `new HttpClient()`/`new Api()`. Any consumer who generates and then instantiates the client executes attacker code with the importing process's privileges. A detailed self-contained proof-of-concept exists (exfiltrating /etc/passwd), so publicly available exploit code exists; this is not listed in CISA KEV and there is no evidence of active exploitation.

Authenticated remote code execution in Axway SecureTransport (all versions prior to 5.5-20260528, confirmed present in 5.5-20260326) allows an administrator to inject Java expressions into mail templates that are evaluated server-side when emails are rendered and sent, resulting in full host compromise. The flaw is a Server-Side Template Injection (CWE-1336) reported by Toreon and fixed by Axway; no public exploit identified at time of analysis, though a technical write-up and vendor advisory exist. Because exploitation requires admin privileges (CVSS 4.0 PR:H), risk is bounded to trusted or compromised administrative accounts despite the 9.4 severity.

Out-of-bounds write in Schneider Electric IGSS (Interactive Graphical SCADA System) Definition module allows an attacker to corrupt memory - causing data loss or potential arbitrary code execution - when a victim imports a maliciously crafted CGF (configuration/definition) file. Exploitation is local and hinges on user interaction (opening/importing the file), with no authentication required once the operator is tricked. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but the vendor (Schneider Electric PSIRT) rates the flaw high at CVSS 8.4.

Remote code execution, denial of service, and data compromise affect a Schneider Electric industrial product exposing a Modbus TCP interface, where improper handling of unusual or exceptional Modbus conditions (CWE-754) lets a network attacker crash the device or run arbitrary code. The CVSS 4.0 base score of 9.3 with a network, no-privilege, no-interaction vector indicates unauthenticated remote exploitation is feasible. There is no public exploit identified at time of analysis and the flaw is not listed in CISA KEV, but the combination of protocol exposure and full confidentiality/integrity/availability impact makes it a serious OT concern.

Remote code execution in the Extra Checkout Options addon (for Extra Product Options & Add-Ons for WooCommerce) affects all WordPress installs running versions through 2.3.2, letting authenticated Subscriber-level attackers upload PHP web shells. Two flaws chain together: eco_save_settings() lacks authorization and nonce checks so a low-privileged user can add 'php' to the tc_eco_custom_file_types upload allowlist, and the wc_eco_upload_file AJAX action performs insufficient authorization, permitting file upload via the frontend nonce exposed on cart and checkout pages. There is no public exploit identified at time of analysis, but the CVSS 8.8 rating and the fact that only Subscriber access is required make this a serious risk; note the vendor only partially fixed it in 2.3.2.

Out-of-bounds write in GNU binutils' BFD library (bfd/elf32-dlx.c) lets a crafted ELF/DLX object file corrupt memory and achieve arbitrary code execution when parsed by any BFD-consuming tool (objdump, readelf, strip, ld, nm, objcopy). Reported by Red Hat and tracked against RHEL 6-10, Hardened Images and OpenShift 4, the flaw is only reachable when binutils is compiled with the DLX backend (typically --enable-targets=all), so exposure is gated by a non-default build option. There is no public exploit identified at time of analysis (not in CISA KEV), though the researcher demonstrated code execution via a File Stream Oriented Programming (FSOP) attack on glibc FILE structures.

Remote code execution in the Aimy Captcha-Less Form Guard plugin for Joomla (versions 18.0 through 20.0) allows unauthenticated attackers to run arbitrary PHP by submitting a forged 'clfgd' form field that the plugin deserializes, triggering PHP object injection. Any unpatched Joomla site running this plugin is exposed to full server compromise over the network without authentication or user interaction. There is no public exploit identified at time of analysis and the flaw is not listed in CISA KEV, but the CWE-502 root cause and maximal CVSS 4.0 score (10.0) make this a critical-priority issue.

Remote code execution in the StyleMixThemes Cost Calculator Builder PRO WordPress plugin (versions up to and including 4.0.3) lets unauthenticated attackers run arbitrary PHP on the server by injecting non-word XOR gadgets into the orderDetails[*].originalValue field, which is passed verbatim into a PHP eval() call inside js_to_php(). The only gate is a nonce, but that nonce is printed on every front-end page via wp_head, so any anonymous visitor can retrieve it, effectively removing the authentication barrier. There is no public exploit identified at time of analysis and it is not listed in CISA KEV, but the CVSS 9.8 rating and trivial nonce bypass make this a high-priority, pre-authentication server-takeover flaw.

Remote code execution in Koollab LMS 5.3.2 lets an authenticated attacker chain SQL injection (CWE-89) and PHP object injection through the manual mark assessment endpoint to poison data reaching unserialize(), drop a webshell into a web-accessible path, and run arbitrary commands on the host. The chained SQLi-to-deserialization-to-webshell path yields total system compromise (CVSS 9.9, scope change). There is no public exploit identified at time of analysis, EPSS is low (0.30%), and CISA SSVC currently rates exploitation as none.

Remote code execution in Koollab LMS allows authenticated attackers to chain SQL injection with unsafe deserialization, ultimately executing arbitrary commands on the server. The vulnerability is reachable via the assessment overall answer endpoint and permits writing a webshell to a publicly accessible location. No active exploitation (KEV) or public exploit code has been confirmed at this time.

Remote code execution in Koollab LMS allows authenticated attackers to exploit SQL injection and unsafe deserialization through the assessment reinforcement endpoint, resulting in webshell upload and full server compromise. The vulnerability, tracked as CVE-2026-63232, requires low-privileged access but leads to complete takeover of the server. No public exploit or active exploitation has been identified at time of analysis.

Arbitrary file upload and remote code execution in Koollab LMS allows an authenticated module designer to achieve full server compromise by uploading a malicious SCORM package containing a PHP webshell. The uploaded file is placed in a publicly accessible directory, enabling the attacker to execute arbitrary commands on the underlying server. No evidence of active exploitation or public exploit code exists at this time, but the CVSS score of 9.9 reflects critical severity.

Unauthenticated remote code execution in the Streamit WordPress theme (versions up to and including 4.5.0) stems from a missing-authorization AJAX endpoint that invokes an attacker-supplied PHP function with attacker-supplied arguments, letting unauthenticated attackers create administrator accounts and run arbitrary code. Reported by WPScan and tracked as EUVD-2026-50115, it carries a CVSS 9.8 and publicly available exploit code exists, though there is no public exploit identified as being used in active attacks at time of analysis.

Arbitrary file upload vulnerability in the Easy Digital Downloads WordPress plugin (≤3.6.9) allows authenticated attackers with Shop Manager-level access to upload malicious files via insufficient validation in the import file upload function, potentially achieving remote code execution. No public exploit or active exploitation reported at time of analysis. The fix was applied in the plugin trunk.

SQL injection in ClickHouse Server versions 26.3.9.8 and earlier lets remote attackers inject arbitrary SQL through the CREATE DICTIONARY functionality, which the advisory claims can escalate to arbitrary code execution. Publicly available exploit code exists (GitHub repository CVE-2026-51992), but there is no CISA KEV listing and no EPSS score in the provided data, so no confirmed active exploitation. The provided CVSS is 9.1, though the description's reference to the CREATE DICTIONARY operation suggests an authenticated privilege may actually be required, which conflicts with the PR:N in the supplied vector.

Code injection in datamodel-code-generator 0.17.0–0.60.1 allows attackers who control a schema’s default_factory value to inject arbitrary Python expressions into generated models, achieving remote code execution when the target imports the poisoned module. The vulnerability affects all supported input types (JSON Schema, OpenAPI, YAML, JSON, Avro, Protobuf, XSD) and output model types (Pydantic v2, dataclass, msgspec). Public exploit code exists; the issue is fixed in version 0.60.2.

Code injection via unescaped validator entries in datamodel-code-generator's --extra-template-data feature allows arbitrary Python code execution when a generated Pydantic v2 model is imported. Affects versions 0.52.1 through 0.60.1, with a fix in 0.60.2. Publicly available exploit code exists, though no active exploitation has been reported to CISA KEV.

Code injection via unsanitized schema extensions in datamodel-code-generator allows arbitrary Python code execution when the generated model is imported. Affects versions from 0.11.6 to 0.63.0. Public exploit code exists, but no active exploitation has been confirmed by CISA KEV.

Code injection in datamodel-code-generator versions before 0.60.1 allows an attacker who provides a malicious GraphQL schema to execute arbitrary Python code when a developer generates and imports the resulting model. The flaw exists because carriage return (\r) characters in Union type descriptions are not neutralized before being placed inside Python line comments, letting the rest of the description escape the comment and run as module‑level code upon import. A fix is available in version 0.60.1; no active exploitation is reported, and no public exploit is known.

Code injection in datamodel-code-generator allows an attacker who controls a JSON Schema to embed arbitrary Python code in generated model files, leading to arbitrary command execution when the module is imported. Affected versions 0.51.0 through 0.60.1 lack proper validation of the `x-python-type` extension, making the attack possible with default tool settings. No public exploit is identified at time of analysis, but the vulnerability is patched in version 0.60.2.

We are generating a synthetic analysis for CVE-2026-54654. We have a lot of data: description, CVSS, CWE, tags, references, GHSA advisory with detailed description, PoC, patch commit details, CPE. Need to produce JSON fields as instructed. Fields: product_name, summary, technical_context, risk_assessment, affected_products, remediation, exploit_scenario, exploitation_conditions, attack_chain, confidence_notes, prevalence, prevalence_basis, assessed_cvss_vector, assessed_cvss_rationale, assessed_cvss40_vector. Let's extract key info: - Product: "datamodel-code-generator" (pip package, from koxudaxi). Product name should be 1-3 words: "datamodel-code-generator". - Description: Code injection via unescaped carriage return in `--extra-template-data` comment field, fixed in 0.60.2. - CVSS: 7.8, vector: CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H - CWE-94: Code Injection. - Tags: Python, RCE, Code Injection, Datamodel Code Generator. - KEV: not mentioned, assume not in KEV. POC: mentioned in advisory (secret gist). But we can't confirm if it's public or private secret gist; the advisory says "Complete self contained POC is available at my secret gist", so the reporter likely privately shared with maintainers? Or the link is there? Since the GHSA description says "PoC available at my secret gist: https://...", but the URL is there. It's a public gist? Might be public. But we don't have explicit POC=YES flag. The tags don't say POC available. Advisory text includes PoC section but the URL is given. Could be public. We'll treat as "publicly available exploit code exists" since the gist URL is embedded in the advisory and likely accessible to anyone who reads it. However, we must be careful: the description says "Complete self contained POC is available at my secret gist" - "secret" might indicate private. But it's in a public security advisory, so it's exposed. It's not a standard public POC, but I'll note it as possible public POC. The instructions say: if POC=YES but no

Pre-authentication unsafe deserialization in IBM WebSphere Application Server 9.0 and 8.5 traditional allows remote unauthenticated attackers to execute arbitrary code or bypass authentication. CVSS 9.8 indicates critical severity with low attack complexity and no user interaction, though no public exploit code or active exploitation has been identified at time of analysis.

Arbitrary OS command execution is possible in IBM Aspera Faspex 5 (versions 5.0.0 through 5.0.15.4) through unquoted shell interpolation, allowing a remote attacker who has already obtained high-privilege authentication to run arbitrary commands on the underlying host. The CVSS vector (AV:N/AC:L/PR:H) confirms network reachability with low attack complexity once authenticated, resulting in full confidentiality, integrity, and availability compromise. No public exploit code or CISA KEV listing has been identified at time of analysis; IBM has released a patch via the advisory at https://www.ibm.com/support/pages/node/7280530.

Shell command injection in IBM Aspera Faspex 5 (versions 5.0.0 through 5.0.15.4) permits a remote attacker holding high-privilege credentials to execute arbitrary operating system commands on the underlying server. The CVSS 7.2 High score reflects full confidentiality, integrity, and availability impact, substantially gated by the PR:H authentication requirement. No public exploit has been identified at time of analysis, and both EPSS (1.04%, 60th percentile) and CISA SSVC (Exploitation: none) align on low current exploitation activity; a vendor patch is confirmed available.

Remote code execution in IBM WebSphere Application Server 8.5 and 9.0 (traditional) allows an unauthenticated network attacker to run arbitrary code by sending crafted serialized data that the server deserializes without validation (CWE-502). The flaw carries a CVSS 9.8 rating with a network attack vector and no authentication or user interaction required, though SSVC records exploitation as none observed and no public exploit was identified at time of analysis. EPSS is low at 0.37% (29th percentile), indicating that active, widespread exploitation has not yet materialized despite the maximal technical impact.

Remote code execution in IBM WebSphere Application Server Liberty (versions 17.0.0.3 through 26.0.0.8) allows unauthenticated network attackers to execute arbitrary code when the collectiveController-1.0 feature is enabled. Rooted in a missing-authentication weakness (CWE-306) on collective controller management functions, the flaw carries a 9.8 CVSS score and total technical impact per CISA's SSVC framework. There is no public exploit identified at time of analysis and EPSS is low (0.19%, 9th percentile), but the network-reachable, unauthenticated nature makes it a high-priority patch where the collective feature is in use.

We are tasked with synthesizing a comprehensive analysis about CVE-2026-66745 from multiple sources, outputting a plain-text JSON. Let's go through each field. First, understand the CVE: Artica Proxy before 4.50.000000 Service Pack 7 (fixed in hotfix 20260724-02) has a session fixation vulnerability. Unauthenticated attackers can set a known PHPSESSID on a victim's browser before authentication, and when the victim authenticates via fw.login.php, the attacker gains administrative session on port 9000. CVSS 4.0 vector given: AV:N/AC:H/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N. CWE-94 (Code Injection) is listed, but that seems odd for session fixation; maybe it's misattributed? But we'll use provided data. Tags: RCE, PHP, Code Injection, Artica Proxy. RCE? Session fixation doesn't give RCE directly; maybe there's more to it? Description only mentions session fixation leading to admin session hijack. Might be an error in tags. We'll stay factual. CPE: cpe:2.3:a:articatech:artica_proxy:*:*:*:*:*:*:*:* (all versions pre-fix). Patch: Available, with hotfix version 20260724-02 (provided). References: Articatech wiki, hotfixes page, VulnCheck advisory. Now we need to fill fields. product_name: "Artica Proxy" - that's the product, matches CPE. Only 1-3 words. Yes. summary: Start with specific impact verb and product. Not "A vulnerability..." So: "Administrative session hijacking in Artica Proxy before 4.50.000000 SP7 allows unauthenticated attackers to pre-set a session ID on a victim's browser, then wait for the victim to authenticate via fw.login.php, gaining full administrative control on port 9000. The vulnerability is a session fixation flaw with a CVSS 4.0 base score of 7.5. No exploitation evidence (KEV) or public POC is currently confirmed, but a hotfix is available." It says "session fixation vulnerability that allows unauthenticated attackers to hijack administrative sessions", so impact is administrative session hijack. So summary: "Administrative session h

Out-of-bounds write in Adobe Bridge allows arbitrary code execution when a user opens a malicious file. The vulnerability requires user interaction and runs code in the context of the current user. No active exploitation or public exploit code is known at the time of analysis.

Arbitrary code execution in Adobe Bridge 16.x (through 16.0.5) and 15.x (through 15.1.6) stems from an untrusted search path (CWE-426): when a victim opens a crafted file, Bridge resolves and loads a library from a location an attacker can control, executing code under the victim's own account. The vendor's CVSS 3.1 vector is AV:L/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H (8.2), while our independent assessment scores the same 8.2 band with PR:N and S:U, underscoring that the attack is strictly local, requires mandatory user interaction, and is bounded by the current user's privilege level rather than SYSTEM or root. Exploitation pressure is currently low: there is no public exploit identified at time of analysis, the issue is not in CISA KEV, CISA's SSVC decision framework rates Exploitation 'none' and Automatable 'no', and EPSS is only 0.15% (5th percentile).

Arbitrary code execution in Adobe Bridge allows local attackers to execute arbitrary code in the victim's context by enticing a user to open a malicious file. The out-of-bounds write vulnerability (CWE-787) requires no authentication and has not been reported as actively exploited or in the CISA Known Exploited Vulnerabilities catalog. No public exploit code is known at this time.

Arbitrary code execution in Adobe Bridge up to versions 15.1.6 and 16.0.5 occurs via an untrusted search path vulnerability. A local attacker can craft a malicious file that, when opened by a victim, causes Bridge to load and execute a malicious DLL from an attacker-controlled location, leading to full system compromise in the context of the current user. No active exploitation or public exploit code is known at time of analysis, and EPSS data is not available.

Opening a malicious file in Adobe Bridge triggers an out-of-bounds write, leading to arbitrary code execution with the current user's privileges. Adobe has released a security update to address this issue via bulletin APSB26-89. No active exploitation or public exploit has been identified at the time of analysis.

Arbitrary code execution in Adobe Bridge via a malicious file opened by a victim. An incorrect authorization flaw allows an attacker to bypass security constraints and run code with the current user's privileges. No active exploitation or public proof-of-concept has been reported, but the vulnerability carries a high CVSS score due to scope change and full system impact.

Remote code execution in pglogical extension for PostgreSQL allows a low-privileged user to crash replication workers, with potential for arbitrary code execution. A use-after-free condition in worker signaling code is triggered during normal replication operations when worker lifecycle events race. While typical effect is denial-of-service, a successful exploit can give complete control of the database backend process.

Opening a malicious file in Adobe Format Plugins can trigger a heap-based buffer overflow, allowing arbitrary code execution in the context of the current user. Exploitation requires user interaction, and no active exploitation or public exploit code has been reported at this time.

Arbitrary code execution is possible in the Adobe Photoshop Installer through an uncontrolled search path element (CWE-427), where a malicious library planted in a directory the installer searches is loaded when the installer runs. Exploitation is local and requires user interaction - an attacker must first place a malicious library on the target system and then convince a victim to launch the installer, after which code runs in the context of that user rather than with elevated privileges. Public exploitation signals are weak: there is no confirmed active exploitation (not in CISA KEV), no public exploit identified at time of analysis, and EPSS is only 0.17% (7th percentile), although the CVSS base score of 8.6 and a 'total' technical impact rating keep it relevant for hardening. The CVSS vector (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H) indicates a local, unauthenticated attack path that nonetheless depends on user initiation and a writable directory within the installer's search path.

Heap-based buffer overflow in ESP32-audioI2S version 3.4.5 allows remote code execution, information disclosure, denial of service, or privilege escalation when processing a malicious WAV file. The flaw resides in the read_WAV_Header() function due to lack of bounds checking on chunk size and bytes-to-skip values, enabling heap corruption. A public proof-of-concept exists (CISA SSVC 'poc'), but no active exploitation has been confirmed in CISA KEV.

Authenticated remote code execution in Camaleon CMS 2.1.1 through 2.9.1 lets users who hold the custom_fields manage permission store an arbitrary Ruby expression in the 'command' option of a select_eval custom field, which is then evaluated via instance_eval inside an ERB view whenever a post edit page is rendered, yielding code execution with web-server process privileges. Publicly available exploit code exists (including a public proof-of-concept repository and writeup), but the flaw is not listed in CISA KEV and EPSS is modest at 0.74% (51st percentile), so practical risk concentrates on installations that delegate custom-field management to non-administrative roles. The vulnerability requires an authenticated principal with that permission (CVSS vector PR:L), and is not reachable by anonymous users.

Arbitrary file write in @wakaru/cli versions 1.0.0 to 1.3.x allows attackers who can trick a user into running `wakaru --unpack` on a crafted bundle to write files outside the intended output directory. The flaw stems from incomplete sanitization of bundle-controlled filenames containing overlapping path traversal sequences like `....//`, which after sanitization become `../`. Successful exploitation can lead to code execution if an overwritten file is executed later.

Arbitrary command execution in WordPress Coding Standards (WordPressCS) before 3.4.1 lets attacker-controlled PHP source trigger code execution on the machine running the linter. The flawed WordPress.WP.EnqueuedResourceParameters sniff reconstructed the $ver argument of wp_enqueue_script()/wp_register_script() and passed it to eval(), so scanning a malicious file (for example a pull request in CI) with the WordPress or WordPress-Extra rulesets runs the attacker's payload. There is no public exploit identified at time of analysis and EPSS is low (0.18%), but the technical impact is total and a patched release (3.4.1) is available.

Memory corruption in Samsung's proprietary ImsService - the IP Multimedia Subsystem component handling VoLTE, Wi-Fi Calling and SIP signaling - can be triggered by a crafted message to produce an out-of-bounds write (CWE-787) and potentially execute arbitrary code on affected Samsung Galaxy devices. Devices running Android 14, 15 or 16 with firmware older than the SMR Jul-2026 Release 1 are exposed; exploitation requires reaching the IMS service stack (per the CVSS 4.0 vector it is unauthenticated with no user interaction, but AT:P indicates a non-attacker-controlled precondition such as an established or negotiable IMS session, a malicious IMS peer, or a position in the carrier signaling path), and confirmed impact is integrity and availability only, with no confidentiality loss. There is no evidence of active exploitation (not in CISA KEV), no public exploit code identified at time of analysis, and EPSS is low at 0.40% (32nd percentile), though the CISA SSVC assessment rates technical impact as total and patch availability (SMR Jul-2026 Release 1) limits the population of vulnerable devices over time.

Remote code execution in Balbooa Forms prior to version 2.4.3 allows unauthenticated attackers to execute arbitrary PHP code on the Joomla server. Exploitation requires forms that include the signature field type, where insecure processing logic can be triggered via a crafted submission. No public exploit or active exploitation has been identified at the time of analysis.

Unauthenticated remote code execution in 3DEXPERIENCE Station Launcher App from Release R2023x through R2026x allows attackers to execute arbitrary commands on affected systems without any authentication. The flaw stems from deserialization of untrusted data (CWE-502) and carries a maximum CVSS 10.0 score. No active exploitation or public exploit code is reported at time of analysis, though the network‑accessible attack surface presents significant risk.

Remote code execution in Apache Axis2/Java through 2.0.0 arises from unsafe deserialization of Java objects in the optional Tribes clustering component, allowing unauthenticated remote attackers with network access to the clustering port to execute arbitrary code via crafted serialized payloads. The vulnerability is only exploitable when clustering is explicitly enabled, which is off by default. No active exploitation or public exploit code has been observed; the issue is resolved by upgrading to version 2.0.1, which removes the entire clustering feature.

Arbitrary file deletion in the Better Messages WordPress plugin allows authenticated administrators to delete arbitrary server files by exploiting a path traversal flaw in the delete_sticker function. The vulnerability, present in versions up to 2.15.19, enables an attacker with admin access to craft a URL that bypasses directory restrictions via embedded ../ sequences, potentially leading to remote code execution when critical files such as wp-config.php are deleted. No active exploitation or public proof-of-concept has been reported at this time.

Heap-based buffer overflow in ESP32-audioI2S 3.4.5’s ID3v2 APIC frame parser lets remote attackers execute arbitrary code or crash vulnerable devices by supplying a crafted MP3 file. A proof-of-concept exploit is publicly available, but no active exploitation has been confirmed.

Heap-based buffer overflow in ESP32-audioI2S 3.4.5 allows remote attackers to cause denial of service, information disclosure, or arbitrary code execution via a crafted MP3 file. Public exploit code is available but no active exploitation is confirmed.

Heap-based buffer overflow in ESP32-audioI2S version 3.4.5 allows remote attackers to execute arbitrary code, disclose information, crash the service, or escalate privileges by sending a malicious URL with an oversized path and query string to the vulnerable urlencode function. No active exploitation has been confirmed by CISA KEV, and no EPSS score is available at this time.

Heap-based buffer overflow in the connecttospeech() function of schreibfaul1 ESP32-audioI2S version 3.4.5 allows remote attackers to achieve arbitrary code execution by supplying an overly long speech text string. The flaw arises because the library performs URL encoding of attacker-controlled input and appends it to a fixed-size heap buffer without length validation, leading to a heap overflow. A public proof-of-concept exploit is available, but active exploitation has not been confirmed.

Remote code execution in schreibfaul1 ESP32-audioI2S 3.4.5 allows unauthenticated attackers to overflow a heap buffer via crafted HTTP request headers. Public exploit code is available, enabling arbitrary code execution on vulnerable ESP32 devices. No official patch has been released.

Heap-based buffer overflow in the schreibfaul1 ESP32-audioI2S library (version 3.4.5) exposes ESP32-based audio devices to remote code execution when they parse malicious HTML entities in streamed content. The flawed htmlToUTF8() decoder rearranges string data with memmove/memcpy without checking remaining buffer space, so an attacker who controls the HTML the device fetches (e.g. a web-radio stream or its metadata) can force an out-of-bounds heap write leading to code execution, memory disclosure, or a crash. Publicly available exploit code exists per the CISA SSVC 'poc' status, but the flaw is not listed in CISA KEV and carries a low EPSS score of 0.27% (19th percentile), indicating no evidence of widespread active exploitation yet.

An integer underflow in the MP3 decoder of ESP32-audioI2S v3.4.5 allows potential arbitrary code execution via a specially crafted MP3 file. The vulnerability, caused by unchecked bit reading operations in the MP3Decoder::GetBits() function, can lead to invalid bit manipulation, application crash, or code execution. Exploitation requires a user to open a malicious MP

Heap-based buffer overflow in schreibfaul1 ESP32-audioI2S library version 3.4.5 allows remote unauthenticated attackers to corrupt PSRAM memory, leading to denial of service and potential arbitrary code execution. An unchecked unsigned integer overflow when allocating a buffer for audio processing results in an undersized allocation; subsequent read/write operations overrun the heap. A proof-of-concept exploit is publicly available, but the vulnerability is not listed in CISA's Known Exploited Vulnerabilities catalog.

Heap out-of-bounds write in schreibfaul1's ESP32-audioI2S library version 3.4.5 stems from an unsynchronized AudioBuffer::freeSpace() calculation that concurrent FreeRTOS tasks can race, producing an inflated free-space value that callers trust when writing decoded audio. Successful exploitation corrupts heap memory on the ESP32 microcontroller, causing crashes and potentially arbitrary code execution. No public exploit identified at time of analysis; EPSS is low (0.16%, 5th percentile) and CISA SSVC records exploitation status as none, indicating no observed in-the-wild activity despite the 9.8 CVSS.

We are tasked with producing a comprehensive JSON analysis for CVE-2026-51273. We have multiple intelligence sources: mitre (CVE description, CVSS, CWE, references), tags, SSVC, ENISA EUVD. The input provides the CVE ID, description, CVSS score, vector, CWE, and multi-source intel including CPE, references, tags, SSVC, and EUVD data. We must synthesize all this into a JSON object with the specified fields, each a plain text string. First, let's parse all the given data: - CVE ID: CVE-2026-51273 - Description: "In schreibfaul1 ESP32-audioI2S 3.4.5, a heap-based buffer overflow vulnerability exists in the ID3 tag parsing function showID3Tag() of the embedded audio streaming library. The program reads untrusted long ID3 tag value from malicious audio files and uses unbounded appendf() to write formatted strings into ps_ptr heap buffer without length validation. Successful exploitation allows attackers to execute arbitrary code, leak sensitive memory data, cause device crash, or escalate privileges via a crafted malicious audio file." - CVSS Score: 7.8 - CVSS Vector: CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H - CWE: CWE-122 (Heap-based Buffer Overflow) - Reported by mitre. - CPE (affected products): cpe:2.3:a:n/a:n/a:*:*:*:*:*:*:*:* (this is a placeholder; the real product is schreibfaul1 ESP32-audioI2S, but CPE string is given as "n/a:n/a"). So product is "ESP32-audioI2S" by schreibfaul1. But the CPE doesn't provide a proper string; we'll note that in confidence_notes. - Tags: RCE, Buffer Overflow, N A, Heap Overflow - SSVC: Exploitation: poc, Automatable: no, Technical Impact: total. So a proof-of-concept exists, but exploitation is not automatable. - ENISA EUVD: EUVD-2026-49928, affected versions: ["n/a n/a"] (again placeholder). So no specific version range from EUVD, but description says version 3.4.5 is affected. - References: 1. (None) https://github.com/schreibfaul1/ESP32-audioI2S/blob/master/src/Audio.cpp (source code link) 2. (None) https://github.com

Arbitrary code execution via buffer overflow in Apple iOS, iPadOS, and macOS. Processing a maliciously crafted file can

Processing a maliciously crafted file on unpatched Apple operating systems (iOS, iPadOS, macOS, tvOS, watchOS, visionOS) may allow arbitrary code execution due to an integer overflow in file handling. The vulnerability affects all versions prior to the latest OS updates and requires user interaction (opening a file) to trigger. No active exploitation or public exploit code has been identified, and patches are available in the vendor-released updates.

Buffer overflow in macOS versions prior to 15.7.8, 14.8.8, and 26.6 allows a malicious app to escape its

Arbitrary code execution in Apple iOS, iPadOS, and macOS arises when the OS image-processing pipeline handles a maliciously crafted image, triggering an integer overflow (CWE-190) that can be leveraged to run attacker-controlled code. The flaw affects iOS/iPadOS before 26.6 and multiple macOS trains (Sonoma before 14.8.8, Sequoia before 15.7.8, Tahoe before 26.6) and requires the victim to open or process the malicious image (UI:R). No public exploit has been identified at time of analysis, EPSS is low (0.18%, 7th percentile), and it is not listed in CISA KEV.

We are tasked with producing a JSON analysis for CVE-2026-64747. We must use all provided data, including EPSS, SSVC, patch availability, CPE, and tags. The vulnerability is a buffer overflow in Apple products, with an app potentially executing arbitrary code with kernel privileges. CVSS 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H). CWE-120. Patch available from vendor. EPSS 0.19% (low). SSVC: Exploitation none, Automatable no, Technical impact total. KEV status? Not in input, so not KEV. POC? Not mentioned. Tags include RCE, Apple, Buffer Overflow, etc. Affected products: iOS 26.6, iPadOS 26.6, macOS Sequoia 15.7.8, macOS Sonoma 14.8.8, macOS Tahoe 26.6, tvOS 26.6, visionOS 26.6, watchOS 26.6. CPEs confirm. References are Apple support pages. We must produce fields: - product_name: 1-3 words, specific product. Since it spans many OSes, the "primary one"? The CVE description mentions iOS and iPadOS, macOS, tvOS, visionOS, watchOS. The common underlying component is likely the kernel or something. But the product is Apple's operating systems. Could say "Apple OS Family" or "Apple Kernel". The description says "An app may be able to execute arbitrary code with kernel privileges." So the vulnerability is in the kernel, accessible via an app. So product could be "Apple Kernel" or "Apple Operating Systems". But the instruction says "The specific product or service name affected. Examples: 'Apache Tomcat', 'WordPress', 'Linux Kernel'." So maybe "Apple Kernel". However, it's not explicitly named. The CPEs list specific products: ios_and_ipados, macos, tvos, visionos, watchos. So I'll use "Apple OS Family" but that is 3 words. "Apple Kernel" is 2 words. I'll go with "Apple Kernel" as the vulnerable component. The description isn't clear if it's the kernel itself or a system library, but "kernel privileges" suggests kernel execution. So "Apple Kernel" is appropriate. - summary: 2-3 sentences, original synthesis, avoid starting with "A vulnerability". Start with impact verb a

Arbitrary code execution via malicious file processing affects multiple Apple operating systems due to an out-of-bounds write. Fixed in iOS 26.6, iPadOS 26.6, macOS Sequoia 15.7.8, macOS Sonoma 14.8.8, macOS Tahoe 26.6, tvOS 26.6, visionOS 26.6, and watchOS 26.6. No active exploitation or public exploit is known, and EPSS predicts a very low probability of real-world attacks.

Processing a maliciously crafted file on Apple operating systems can lead to arbitrary code execution due to an integer overflow vulnerability (CWE-190). Affected products include iOS, iPadOS, macOS, tvOS, visionOS, and watchOS, all prior to their respective fixed versions. No public exploit code has been identified, and the EPSS score of 0.17% indicates a very low probability of near-term exploitation, though the impact could be severe.

Arbitrary code execution in Apple macOS through image processing is fixed in macOS Sonoma 14.8.8, Sequoia 15.7.8, and Tahoe 26.6. A buffer overflow in handling maliciously crafted images allows local attackers to execute arbitrary code with the victim's privileges upon opening the file. No active exploitation or public proof-of-concept is reported; EPSS predicts low exploitation probability (0.19%).

Arbitrary code execution in Apple iOS and iPadOS, macOS, tvOS, visionOS, and watchOS permits an attacker to run code or terminate apps by luring a user into opening a crafted file. The out-of-bounds write issue was fixed in all supported Apple operating systems via June 2026 updates. No active exploitation or public proof-of-concept has been reported at time of analysis, and EPSS indicates a low probability of future exploitation.

Arbitrary code execution in Cribl Stream before 4.18.2 allows a remote authenticated attacker with Pack import and pipeline preview permissions to compromise the server. The attacker can execute arbitrary code as the Cribl server process by importing a crafted Git repository containing a symbolic link in the pack's functions directory. No public exploit is known, and there is no evidence of active exploitation at this time.

Arbitrary JavaScript execution in Cribl Stream before 4.18.2 allows authenticated attackers with edit privileges to run arbitrary code on the server via crafted database connection identifiers or pack configuration values. The vulnerability stems from improper code generation in the JSON Pointer-to-accessor compiler. No public exploit or active exploitation has been reported.

Arbitrary code execution in GIMP when opening a crafted FITS file due to an integer overflow in the file-fits plugin that leads to a heap buffer overflow. An attacker can achieve memory corruption and potentially execute arbitrary code with the user's privileges. No public exploit or active exploitation has been identified at time of analysis.

Remote code execution in JetBrains TeamCity before 2026.1.3 and 2025.11.7 allows unauthenticated attackers to execute arbitrary code via deserialization of untrusted data in the agent polling protocol. The vulnerability carries a CVSS 9.8 score and poses immediate risk to any exposed TeamCity instance. No public exploit or active exploitation has been confirmed at the time of analysis.

OS command injection in NVIDIA NeMo for Linux allows a local authenticated attacker to execute arbitrary commands, leading to full system compromise (code execution, privilege escalation, data tampering, and information disclosure). No public exploit code or active exploitation has been identified at the time of analysis.

Remote code execution in phpMyFAQ before version 4.1.6 allows authenticated administrators with CONFIGURATION_EDIT and ATTACHMENT_ADD privileges to write arbitrary PHP files to the server. By uploading a malicious ZIP file as an attachment and then manipulating the upgrade.lastDownloadedPackage configuration setting to point to that file, an attacker can extract attacker-controlled PHP code into the web root, leading to code execution as the web server user. No known public exploit code or active exploitation has been reported at the time of this analysis.