Use-after-free in Chrome's DOM implementation lets a remote attacker who gets a victim to load a crafted HTML page run arbitrary code inside the renderer sandbox. Every Chrome build before 157.0.8103.38 is affected; the user must actively open the attacker's page (UI:R), but no credentials or non-default configuration are needed (PR:N). Exploitation is confined to the sandbox per the advisory, so host compromise would need a separate sandbox escape; no public exploit or active exploitation is recorded (SSVC exploitation: none) and vendor patches are released, making this a genuine high-priority browser fix rather than an emergency.
Remote code execution inside the GPU process sandbox in Google Chrome before 157.0.8103.38 allows a remote attacker to run arbitrary code when a victim loads a crafted HTML page, with user interaction required (CVSS 8.8, AV:N/AC:L/PR:N/UI:R). Impact beyond the GPU sandbox would require chaining with a separate sandbox-escape vulnerability, and SSVC records Exploitation: none and Automatable: no. A vendor patch is available in 157.0.8103.38; no active exploitation or public exploit was identified at time of analysis, and the priority decision is this_week.
Use-after-free in Google Chrome's Layout component before 157.0.8103.38 lets a remote attacker who convinces a victim to open a crafted HTML page execute arbitrary code inside the renderer sandbox. No authentication or special configuration is needed, but exploitation depends on user interaction with attacker-controlled content, so it is not automatable per SSVC and no public exploit or active exploitation is reported at time of analysis. Code execution stays within the renderer sandbox, so host compromise would additionally require a separate sandbox escape; the vendor fix is Chrome 157.0.8103.38.
Type confusion in the V8 JavaScript engine allows remote code execution inside the renderer sandbox in Google Chrome versions prior to 157.0.8103.38. An unauthenticated attacker can trigger the flaw by getting a victim to load a crafted HTML page, which requires user interaction; successful exploitation yields arbitrary code execution but remains confined to the renderer sandbox absent a separate sandbox escape. No public exploit code has been identified at time of analysis, no active exploitation is confirmed (not in CISA KEV), and CISA SSVC rates exploitation as none with automation not demonstrated, supporting a 'this week' remediation priority rather than an emergency response.
Remote code execution in Google Chrome allows an attacker to run arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page; the flaw is a use-after-free (CWE-416) in Chrome's Editing component affecting all builds prior to 157.0.8103.38. Exploitation requires user interaction (UI:R) with no authentication needed (PR:N), and any code execution is confined to the browser sandbox unless chained with a separate sandbox-escape. There is no confirmed active exploitation (SSVC Exploitation: none) and no public exploit identified at time of analysis; the vendor has released a fixed build and the priority is 'this_week' rather than emergency.
Heap-based buffer overflow in Google Chrome's media handling lets a remote attacker execute arbitrary code inside the browser sandbox when a victim loads a crafted HTML page, affecting every Chrome build prior to 157.0.8103.38. The flaw carries an 8.8 CVSS score (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), meaning no credentials are needed but the user must be lured to the malicious page; the resulting code execution is confined to the sandbox, so host compromise would require a separate sandbox escape. No public exploit code has been identified at time of analysis and SSVC records exploitation as none, though CISA's framework rates technical impact as total; vendor-released patch 157.0.8103.38 is available and the item is prioritized for remediation this week.
This is a genuine high-priority patching item but not an emergency: remote code execution inside the Chrome sandbox is achievable in Google Chrome builds prior to 157.0.8103.38 through a use-after-free in the PDFium PDF engine, triggered when a victim opens attacker-controlled content such as a crafted HTML page embedding or loading a malicious PDF. No authentication is required (PR:N), but user interaction is required (UI:R), and exploitation yields code execution inside the sandbox; full host compromise would require chaining with an additional sandbox-escape vulnerability. No public exploit has been identified at time of analysis, and the vendor has released 157.0.8103.38; priority is this_week.
Use-after-free in Google Chrome's Compositing component allows a remote attacker to achieve arbitrary code execution inside the renderer sandbox by getting a victim to open a crafted HTML page in any build prior to 157.0.8103.38. The attacker needs no credentials or prior access (PR:N) but must win user interaction (UI:R), and the resulting execution is confined to the sandbox - full host compromise would require a separate sandbox escape not covered by this CVE. Vendor-released patch: 157.0.8103.38; no public exploit code has been identified at time of analysis, no KEV listing is present, and CISA SSVC records exploitation as none, which places this as a this-week remediation item rather than an emergency.
Remote code execution inside Chrome's renderer sandbox affects Google Chrome versions prior to 157.0.8103.38 through a type-confusion flaw in the V8 JavaScript engine. An unauthenticated remote attacker can trigger the flaw only when a user loads a crafted HTML page (CVSS UI:R, PR:N), and the supplied SSVC assessment marks the issue as not automatable with exploitation recorded as none. No public exploit identified at time of analysis; Vendor-released patch: 157.0.8103.38, and renderer-only code execution would require a separate sandbox escape to reach the host.
Use-after-free in Chrome's PerformanceAPIs lets a remote attacker who gets a victim to open a crafted HTML page execute arbitrary code inside the renderer sandbox on versions prior to 157.0.8103.38. Exploitation requires the user to load attacker-controlled content (UI:R) but no credentials or privileges (PR:N), and any code execution stays confined to the renderer until a separate sandbox escape is chained; the issue is rated High by Chromium and carries an 8.8 CVSS. No public exploit code has been identified at time of analysis and the flaw is not in CISA KEV, but the vendor fix should be applied on this week's patch cycle given the memory-corruption RCE class and broad desktop install base.
A use-after-free in Google Chrome's SVG rendering code allows remote attackers to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page containing malicious SVG content, affecting Chrome builds prior to 157.0.8103.38. Exploitation requires user interaction with attacker-controlled web content (UI:R) but no authentication (PR:N), and any code execution obtained is confined to the sandbox unless chained with a separate sandbox-escape flaw. No confirmed active exploitation or public exploit code has been identified, exploitation is not automatable per SSVC, and a vendor patch is available - the issue is rated this_week priority rather than an emergency.
Code execution inside the Chrome renderer sandbox is possible in Google Chrome builds prior to 157.0.8103.38, where improper adherence to coding standards in XML handling (CWE-710) lets a remote attacker who convinces a victim to load a crafted HTML page achieve high confidentiality and integrity impact within the browser's sandboxed process. The flaw is network-reachable, low complexity and requires no authentication, but it is gated by user interaction (UI:R) and its scope is Unchanged, so host-level compromise would need a separate sandbox escape. No public exploit has been identified at time of analysis, CISA SSVC records Exploitation: none and Automatable: no, and Google has released a fixed build (157.0.8103.38); the vuln.today priority places remediation in the this_week window.
Heap buffer overflow in Google Chrome's Media component before 157.0.8103.38 allows a remote attacker to execute arbitrary code inside the renderer sandbox when a victim loads a crafted HTML page. Exploitation requires user interaction (CVSS UI:R) with attacker-supplied content and no authentication or special privileges (PR:N), and the resulting code execution stays contained within Chrome's sandbox, so full host compromise would need a separate sandbox-escape flaw. There is no CISA KEV entry and no public exploit identified at time of analysis, and Google has released the fix in Chrome 157.0.8103.38, making this a patch-this-week item rather than an emergency for environments running affected Chrome builds.
Type confusion in Google Chrome's CacheStorage component allows a remote, unauthenticated attacker to execute arbitrary code inside the browser sandbox when a victim loads a crafted HTML page in any desktop build before 157.0.8103.38. Exploitation requires user interaction, and the resulting code execution is confined to the renderer sandbox, so host-level compromise would require chaining with a separate sandbox escape. No public exploit was identified at the time of analysis, and the vendor has released Chrome 157.0.8103.38 as the fix; assessed CVSS is 8.8.
Use-after-free in Google Chrome's Geometry component before 157.0.8103.38 lets a remote attacker who convinces a victim to load a crafted HTML page execute arbitrary code inside the renderer sandbox. The issue is rated CVSS 8.8 with UI:R and PR:N, so default Chrome installations below the fixed version are exposed when the victim renders attacker-controlled content; no public exploit was identified at the time of analysis, and code execution from this flaw alone remains confined to the sandbox unless chained with a separate escape.
Sensitive credential disclosure in the HPE Networking Fabric Composer API allows an authenticated low-privileged user to read data beyond their authorized privilege level, including credentials stored on the system. The flaw is network reachable with low attack complexity and no user interaction, and the independent assessment rates confidentiality impact as high with no integrity or availability impact. No public exploit was identified at time of analysis, and the vuln.today priority is this_week.
Local privilege escalation in the HPE Virtual Intranet Access (VIA) client allows an authenticated attacker who already holds low privileges on an endpoint to execute arbitrary commands with elevated operating-system rights. The CVSS 3.1 score is 8.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), reflecting high confidentiality, integrity and availability impact plus a scope change, but the local attack vector means the attacker must first establish a foothold on the host. No public exploit identified at time of analysis and active exploitation is not confirmed in the supplied intelligence; the vulnerable VIA component and affected version ranges are not described, and the vuln.today decision label is this_week.
isomorphic-git's git.checkout writes working-tree files through symlinked leading directory components without validating them, so a malicious repository can escape the checkout directory and overwrite arbitrary host files. Deployments using the Node fs provider on Linux or macOS are exposed to writes anywhere the process can reach - the advisory's demonstrated path injects an SSH key into ~/.ssh/authorized_keys, and an alternative plants hooks or rewrites .git/config to achieve code execution on the next native git command. Exploitation requires the victim to clone and later pull (or otherwise access) an attacker-controlled repo, which is the UI:R component of the CVSS 8.8 vector; Node fs on Windows typically fails at symlink creation with EPERM, and browser/in-memory providers are confined to their virtual filesystem. No public working exploit is confirmed in the provided data, though a public PoC reference (av1-symlink-hook-rce) accompanies the advisory; fixed in 1.38.6.
Use-after-free in SurrealDB Core before 3.3.0 can crash or corrupt memory in Rust applications that embed the database as a library. The defect affects KV backends that pass borrowed transaction state into affinitypool::spawn_local closures; the embedder must leak the returned future and then drop the transaction while a pool worker is still running, defeating the future's Drop-based safety barrier. Exploitation is local and in-process - remote SurrealQL, JS, WASM, or RPC input cannot reach the leak - and a proof-of-concept is documented in the advisory, though publicly available working exploit code is not confirmed in the provided data.
Incorrect boundary conditions in Mozilla Firefox's Layout: Block and Inline component, fixed in Firefox 159.0.1, can cause memory corruption with high confidentiality, integrity and availability impact (CVSS 8.8). An unauthenticated remote attacker can only trigger the flaw if the victim loads attacker-controlled web content that reaches the affected layout code, which is the user-interaction requirement (UI:R); default browser configurations are affected because this is core rendering code. No public exploit identified at time of analysis, SSVC assesses exploitation as none and the attack as not automatable, and this is a genuine high-priority issue but not an emergency by the input signals.
A use-after-free in Zephyr's CAN subsystem lets a local, unprivileged user-mode thread corrupt kernel heap memory by registering a CAN RX filter against a message queue whose lifetime it controls, then releasing or exiting to free that queue while the CAN controller driver still holds a raw pointer to it. The flaw affects builds with CONFIG_USERSPACE=y and CONFIG_DYNAMIC_OBJECTS=y (the latter is default-off but is automatically selected by CONFIG_DYNAMIC_THREAD together with CONFIG_USERSPACE), and requires that the thread already hold a deliberate application-level grant to a CAN device; the next matching CAN frame is then copied through the reused block's write_ptr in supervisor context, and the queue's wait_q (and poll_events under CONFIG_POLL) list nodes are manipulated, crossing the user-to-kernel boundary with high confidentiality and integrity impact. No CISA KEV entry and no EPSS signal are present in the supplied data, but a public proof-of-concept reproducer (delivered via CAN_MODE_LOOPBACK on qemu_x86_64) is published with the vendor advisory; it demonstrates the dangling-pointer path and address reuse with a supervisor-owned queue but is not confirmed as weaponized exploit code.
Authenticated arbitrary file upload in the BuddyBoss App plugin for WordPress, affecting all versions through 3.2.1, lets any subscriber-level user or higher submit files through the send_feedback function, which trusts only the client-supplied Content-Type header and performs no server-side content or extension validation. Uploaded files may be executable, so the defect can lead to remote code execution, but the assessed vector is AC:H because reliable code execution depends on winning a race during the SMTP/email-send window before the file is deleted, or on wp_mail() failing and leaving the file on disk indefinitely. No public exploit was identified at time of analysis, and the issue is not in CISA KEV.
SQL injection in RosarioSIS before 12.9 allows any authenticated non-student user - teacher, staff, or parent account - to inject arbitrary SQL through the unquoted period_id parameter of the Attendance StudentSummary report, enabling time-based extraction of administrator password hashes and student records as well as data modification via stacked statements. Exploitation requires valid credentials for a non-student role on a network-reachable instance; the vendor corrected the flaw in release 12.9 by casting the parameter to an integer. No public exploit code has been identified at time of analysis, but low attack complexity combined with high confidentiality, integrity, and availability impact makes this a prioritize-this-week issue rather than an inflated high-CVSS score.
Memory exhaustion in Kore web server/framework releases before 4.3.0 can be triggered by remote unauthenticated attackers who send first request-body segments larger than the declared Content-Length, bypassing the http_body_max limit and causing unbounded buffer growth. The attack requires sustaining many concurrent POST, PUT, or DELETE connections to exhaust worker memory, so the impact is availability-only; no confidentiality, integrity, or code-execution impact is assessed. No public exploit identified at the time of analysis, and the condition is removed by upgrading to Kore 4.3.0.
HPE Networking Fabric Composer fails to properly validate TLS certificates presented to it, allowing an unauthenticated remote attacker who already holds a man-in-the-middle position on the network path to obtain sensitive information, including credentials. The CVSS 8.7 score (AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N) reflects high confidentiality and integrity impact with a scope change, but the AC:H rating and the vendor's 'preconditions outside the attacker's control' wording reflect the requirement to intercept or redirect the targeted connection before the flawed validation routine can be reached. No public exploit code or confirmed active exploitation was identified in the available intelligence, and the vuln.today decision label is 'this_week'.
Process termination is reachable in applications that use the MongoDB C Driver's GridFS file download API: an internal operation result is left unchecked under certain error conditions during file retrieval, and when stream operations continue the driver dereferences a NULL pointer (CWE-476) and the hosting process aborts. Per the assessed vector (AV:N/AC:L/PR:N/UI:N, availability-only), remote unauthenticated attackers can reach this if the application lets them influence file download parameters, but only through that specific error path - applications that do not use GridFS downloads, or never pass externally influenced parameters to them, are not reachable. Impact is confined to service unavailability with no confidentiality or integrity effect assessed, and no public exploit code is identified at time of analysis; the issue is tracked as MongoDB JIRA CDRIVER-6494 and carries a 'this_week' priority rather than an emergency rating.
Repeated, unbounded memory growth in the MongoDB C Driver occurs when the library handles specially crafted compressed responses from a MongoDB server, because memory allocated for those responses is never released (CWE-401). The driver is unauthenticated and requires no user interaction (CVSS 4.0 8.7; assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:N/A:H, availability-only), so the realistic impact is denial of service against the client application through memory exhaustion. Exploitation is gated by server-side trust rather than by the client's exposure: the attacker must be the database endpoint the application connects to, or be positioned to intercept that connection, and the connection must use MongoDB wire-protocol compression. No public exploit code was identified at time of analysis and the issue is not in CISA KEV; the vuln.today decision label places remediation in this week's patch cycle rather than an emergency response.
Privilege escalation in the Babelfish for PostgreSQL extension (versions 1.2-1.5, 2.1-2.15, 3.1-3.12, 4.0-4.8 and 5.1-5.4) allows remote authenticated users holding only a low-privileged database login to raise their own privileges, with high confidentiality, integrity and availability impact once successful. No user interaction or race condition is required - the assessed vector is CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H - but the attacker must already possess a valid login to a reachable instance, so internet-exposed deployments with shared or loosely managed accounts carry the most risk. There is no public exploit identified at time of analysis and no CISA KEV listing; the vendor states there is no workaround, so only upgrading to 4.10, 5.6 or 6.1 closes the gap.
Remote CPU exhaustion in rsync's delta-transfer sender lets a malicious receiving peer starve a public rsync daemon module of processing capacity. The flaw affects rsync builds through 3.5.1 when exposed through rsyncd with a module that permits anonymous or public pull/download transfers; the attacker supplies weak checksums that collide at consecutive rolling-window offsets while the paired strong checksums do not match, forcing hash_search() in match.c into a per-byte strong-checksum walk instead of the normal per-block stride, and parallel connections compound the load. Impact is availability-only (CVSS 4.0 8.7, VC:N/VI:N/VA:H; independently assessed CVSS 3.1 8.7 AV:N/AC:L/PR:N/UI:N/A:H), no public exploit code exists at time of analysis, and the hard prerequisite is a non-default public daemon deployment - rsync invoked over SSH as a client is not exposed.
Cross-tenant object reference flaw in FastBee through 2.1.0 lets any authenticated tenant user read another tenant's MQTT account, password and secret values, and overwrite or delete foreign product records, by supplying or enumerating sequential product IDs. The by-ID endpoints in ProductController enforced only RuoYi permission strings and omitted the tenant-ownership scoping that the list query applies at the service layer, which yields high confidentiality and integrity impact with limited availability impact (reported CVSS 4.0 score 8.7; independently assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L). Exploitation requires a valid tenant account on a multi-tenant deployment where other tenants' products exist, and no public exploit code or active exploitation was identified at time of analysis.
Foxel through 2.4.0 exposes its virtual filesystem read endpoints, /api/fs/stream and /api/fs/thumb, without any authentication dependency or per-path permission check, so an unauthenticated remote attacker who can reach the instance can retrieve full file contents or generated thumbnails by supplying a VFS mount prefix and a relative path - even for paths that PathRule grants never authorized. The upstream fix commit 73d9fa8 adds a Bearer-token requirement plus a READ path-permission decorator to both handlers and replaces raw stream URLs in the web client with short-lived signed links, and the issue is assessed as a genuine high-priority unauthenticated data-disclosure flaw rather than a CVSS-inflated one. No CISA KEV listing and no public exploit code were identified at time of analysis, though the endpoints are trivially reachable by any client that can perform an HTTP GET, so the practical limiter is network exposure of the Foxel API rather than any attacker prerequisite.
Incorrect authorization in smart-sso through 2.0.1 lets any registered low-privilege user reach admin console APIs, because PermissionFilter only enforces permissions on request paths that are explicitly registered in sso_permission.code and allows every unlisted path by default. The built-in admin console registers page paths such as xxx.html rather than the backend servlet paths, so a default deployment leaves endpoints like /admin/user-role/save reachable; calling it lets an attacker grant themselves the administrator role, reset passwords, and manage users, roles, and applications across integrated systems. Exploitation requires a valid authenticated session (PR:L) and is not possible for a fully anonymous attacker; the vendor has published an upstream fix (commit 9bccabaa5ec5 plus a second commit) and a fixed release version is not stated in the available data. A public PoC reference exists; it is not verified as working exploit code, and no confirmed active exploitation (CISA KEV) was identified at time of analysis.
Arbitrary file write in AB Download Manager before 1.11.2 allows a malicious web page to place attacker-chosen files at any path the desktop application can write, including per-user autostart locations, by posting crafted folder and name values to the /start-headless-download endpoint of its local browser-integration HTTP server. Exploitation is unauthenticated (PR:N) but requires user interaction: the victim must load the attacker's page in a browser on the same host while the integration server is running, since the pre-patch default leaves that API without enforced API-key authentication. The consequence is code execution at the next user login or reboot, when the dropped payload is launched from the startup folder; no public exploit code was identified at time of analysis, and the vendor has released 1.11.2 together with an upstream commit that splits the Ktor routes into auth-optional and auth-required groups and adds an apiKeyEnforced setting.
Authenticated path traversal in Dockhand before 1.0.54 lets any logged-in user read, overwrite, and delete .env files outside the managed stacks root by supplying a double-URL-encoded stack name such as %252e%252e to /api/stacks/[name]/env/raw and roughly eighteen sibling stack routes. Because stack environment files carry database credentials, API keys, and deployment secrets, the flaw exposes cross-environment secrets, permits writes into otherwise guarded directories such as /app/data/db, and enables deploy-time variable poisoning that is interpolated into the next container's environment; unauthenticated requests are rejected with 401, and the cross-tenant dimension is specific to Enterprise RBAC deployments where the trusted env query parameter lets a user scoped to one environment reach another's files. No confirmed active exploitation (CISA KEV) is recorded, but the vendor advisory publishes a public proof-of-concept with captured reproduction output against the official fnsys/dockhand v1.0.53 image; the vendor-released patch is 1.0.54 and the priority signal places remediation in the current week rather than as an emergency.
Algorithmic-complexity denial of service in svg-sanitizer (Composer package enshrined/svg-sanitize) versions 0.11.0 through 1.0.0 lets remote attackers burn extreme CPU by uploading a tiny layered SVG. The <use> reference-graph analysis in Subject.php::hasInfiniteLoop() and countUse() enumerates every root-to-leaf path without memoization, and the only guard (useNestingLimit = 15) caps depth rather than total work, so an acyclic DAG of 15 fanned-out layers (roughly 4-12 KB) projects to tens of hours of CPU for a single sanitize() call; no public exploit code was identified at time of analysis, though the advisory publishes a generator and measured timings. Availability-only impact; the trigger runs during Resolver::collect() before any <use> element is removed, so it cannot be avoided by how the sanitizer later strips elements.
Denial of service in Mistune 3.3.0 through 3.3.3 allows unauthenticated remote attackers to exhaust CPU and stall request workers by submitting small markdown documents that trigger quadratic-time emphasis delimiter processing. The default renderer with no plugins is affected, with repeated "*a_b" driving an O(n²) index-fixup loop; the advisory measured 64KB at roughly 8.2 seconds and a worse "*a**b" pattern at 20.9 seconds for 80KB. The advisory includes a proof-of-concept payload that the reporter reproduced against 3.3.3, no CISA KEV entry or other confirmation of active exploitation is provided, and the vendor has released 3.3.4 as the fix.
Authenticated command injection in AzuraCast through 0.23.8 lets any station user holding the standard Profile permission run arbitrary OS commands on the station backend by planting shell metacharacters in the StereoTool settings, resulting in compromise of the AzuraCast/Liquidsoap container. Exploitation is not anonymous and is not universal: it requires the StereoTool binary to be installed and configured on the target station, and the injected command only fires when the station backend restarts or the Liquidsoap configuration is regenerated. A detailed proof-of-concept request is published in the project's GitHub security advisory, but there is no confirmed active exploitation (not in CISA KEV) and no vendor-released patch was identified at time of analysis; this is a credible, above-average-priority issue rather than an emergency.
Authenticated station managers in AzuraCast through 0.23.8 can turn a station profile edit into root-level command execution by placing a newline-delimited Supervisor [program:] block inside the station timezone field. The value is written into the generated supervisord.conf with only % characters escaped, so the injected program is parsed and executed as root (uid=0 in the vendor's reproduction) when the station configuration is regenerated - whether through the restart API or any later regeneration trigger. The vendor advisory (GHSA-23wx-88m8-pfm2) ships a reproduced proof of concept against 0.23.8 on the official Docker image; this is a this-week priority with no vendor patch available at time of analysis, and exploitation is confined to the AzuraCast runtime (no Docker or host escape was demonstrated).
Configuration injection in AzuraCast through 0.23.8 lets an authenticated station user who holds only the 'Manage station profile' permission rewrite the live Shoutcast sc_serv.conf of a shoutcast2-type station, overriding adminpassword, password and portbase or appending arbitrary directives via newline-bearing keys. The root cause is an authorization gap: PUT /station/{id}/profile/edit strips privileged Liquidsoap backend custom sections for users without 'Manage station broadcasting' but leaves frontend_config.custom_config writable, and that stored JSON is written verbatim as key=value lines into the config file. The injection only materializes when the station or frontend is restarted (in the published proof-of-concept the restart is performed by an admin), and because the Shoutcast binary is absent from stock images, actual daemon execution of the hijacked configuration was not observed. No CISA KEV entry or in-the-wild exploitation is reported, though the upstream GitHub advisory publishes a detailed proof-of-concept and an automated verification script.
Malformed PNG and JPEG image data delivered through the RDP clipboard path terminates FreeRDP client processes up to and including 3.32.1, because WinPR's image readers invoke libpng and libjpeg without the error-handling context those libraries require for untrusted input. A malicious RDP server, or a man-in-the-middle on a session, that offers a crafted image/png or image/jpeg clipboard format can make the client abort (SIGABRT) or call exit() as soon as the format is synthesized, yielding a clean client-side denial of service; a 12-byte PNG and a 62-byte truncated JPEG are sufficient. No client authentication is needed from the attacker, and the advisory publishes reproduction artifacts and a fuzzing harness alongside the source-level root cause, so the trigger is public; the issue is queued as a this_week priority rather than an emergency, and no KEV or EPSS signal was supplied with this report.
Command injection in the IPsec VPN configuration function of Welotec TK100, TK500-v2, and TK500-v3 routers allows a remote attacker who already holds high administrative privileges to inject system commands that run with root privileges. The flaw is network-reachable and needs no user interaction, but the PR:H prerequisite limits it to authenticated high-privileged users; successful exploitation gives full confidentiality, integrity, and availability impact on the device. No public exploit identified at time of analysis, and the independent assessment treats this as a genuine but conditional priority rather than a drop-everything emergency (this_week).
OS command injection in the Digital I/O function of Welotec TK100, TK500-v2 and TK500-v3 gateways allows a remote attacker holding valid high-privilege credentials to inject operating system commands that execute with root privileges, giving full control of the device (CWE-78). All three product lines are listed without version constraints, so every TK100, TK500-v2 and TK500-v3 build should be treated as affected until the vendor's advisory clarifies fixed releases. Exploitation is access-gated rather than open: the attacker must reach the management/configuration interface and already be an authenticated administrative or operator-level user able to invoke the Digital I/O function, and no public exploit has been identified at time of analysis; vuln.today places remediation on a this-week cadence rather than an emergency one.
OS command injection in the WireGuard VPN configuration function of Welotec TK100, TK500-v2 and TK500-v3 industrial routers lets an attacker who already holds administrative access to the device management interface inject and run system commands as root, with no user interaction required. Because the prerequisite is high-privileged management access, this is not a pre-authentication or low-privilege flaw; the practical risk is privilege escalation from an admin-level account or management-plane compromise to full root control of the router. Per the CERTVDE advisory (VDE-2026-119) the issue is improper input validation (CWE-77); no public exploit code or proof-of-concept is identified in the available data, no CISA KEV entry is associated, and EPSS scoring was not available at time of analysis.
Command injection in the ZeroTier VPN function of Welotec TK100 and TK500-v2/v3 devices allows an authenticated attacker with high administrative privileges to inject system commands that execute with root privileges, with high impact to confidentiality, integrity, and availability. The flaw is network-reachable with low attack complexity and no user interaction, but the PR:H requirement means exploitation is limited to actors who already hold administrative-level access to the device. CVSS 4.0 assigns a base score of 8.6 (High); no public exploit was identified at time of analysis.
OS command injection in Welotec TK100, TK500-v2, and TK500-v3 routers allows an authenticated administrator to execute arbitrary commands with root privileges through the management control functions. The flaw is network-reachable and low-complexity, but exploitation is gated by high-privilege access (CVSS PR:H); no public exploit was identified at time of analysis and active exploitation is not confirmed. CERT@VDE tracks it under advisory VDE-2026-119, and vuln.today assigns a this-week remediation priority.
Authenticated users of Volmarg Personal Management System through 2.1.0 can upload a file with a .php extension and base64-encoded content into the web root via the /upload/send/ endpoint, then request it to execute arbitrary code as the web server user. The vendor's CVSS 4.0 vector scores this 8.6 with PR:H, so the flaw is remote and low-complexity but gated behind a privileged authenticated session rather than being exploitable by anonymous attackers. No public exploit code or CISA KEV entry was identified at time of analysis.
Privilege escalation in GLPI's user-cloning feature lets an authenticated Technician clone an existing Super-Admin account and assign the clone new credentials they control, resulting in a fully attacker-owned administrative login. All releases from 10.0.0 before 10.0.28 and 11.0.0 before 11.0.10 are affected, because User::getCloneRelations() and prepareInputForClone() duplicate every Profile_User and Group_User assignment without checking whether the cloning user could grant those rights. Vendor patches and public commits are available, no public exploit code has been identified at time of analysis, and exploitation is access-gated: it requires a Technician (or other user-cloning-capable) session plus the presence of a more privileged account to copy, making this a genuine but scoped priority rather than an internet-wide emergency.
Froxlor 2.3.8 through 2.3.14 renders every stored API key and secret - including the super administrator's - to any authenticated administrator whose customers_see_all flag is set and whose account has API access enabled, because the api_keys.php listing falls into an unscoped WHERE 1 branch and the per-row detail modal prints the credentials verbatim. The API layer compares submitted key and secret verbatim with no owner check, so a reseller-level admin can replay the super administrator's credentials against /api.php to gain full super administrator control and impersonate every customer, a capability their own role does not provide. Exploitation requires a pre-existing privileged multi-tenant admin account (CVSS PR:H, authenticated), a proof-of-concept reproduction is included in the upstream advisory, and no active exploitation has been confirmed (not in CISA KEV).
Cross-user MCP session takeover in SurrealDB 3.1.0 through 3.2.x allows an authenticated holder of even a lowest-role JWT or Bearer token to run MCP tools with a victim's roles and permissions by presenting that victim's mcp-session-id alongside their own valid credential. The flaw only exists when the MCP HTTP transport (POST /mcp) is exposed and the deployment uses a database-, namespace- or root-level DEFINE ACCESS method of TYPE JWT or BEARER that serves more than one user; users authenticated through the user/password signin path and the stdio MCP transport are not affected. Severity is high on paper (CVSS 8.6, C:H/I:H) but the blast radius is capped by those deployment preconditions and by the fact that the attacker cannot exceed the victim's own privileges; the vendor advisory includes a public proof-of-concept reproduction and a fix in 3.3.0, and no confirmed active exploitation or KEV listing is available at time of analysis.
OS command injection in Nagios XI's MIB upload feature (mibs.php) allows an authenticated administrator to execute arbitrary operating system commands as the web server user by uploading a MIB file whose filename is crafted with tab characters and a pipe to sh, evading an incomplete deny-list before the name is handed to a grep command run through exec(). The flaw affects Nagios XI releases before 2026R2 and is gated on a high-privilege administrator account with access to the MIB upload functionality (PR:H in both the CVSS 4.0 score of 8.6 and the assessed CVSS 3.1 vector), making it a post-authentication admin-to-RCE primitive rather than unauthenticated remote code execution. No public exploit has been identified at time of analysis and there is no KEV listing; vendor patch information points to the 2026R2 release.