By severity

High-severity vulnerabilities

CVEs rated High by CVSS, with SEC.co remediation and prioritization guidance.

4140 published vulnerabilities · page 7 of 42

• CVE-2026-5305HIGH 8.8

  A flaw in two WordPress plugins—Email Address Encoder and email-encoder-premium—allows attackers to inject malicious scripts into web pages without authentication. When site visitors view a page containing the attack payload, the scripts execute in their browsers, potentially stealing credentials, session tokens, or triggering unauthorized actions. This is a stored attack, meaning the malicious content persists until the site administrator cleans it up.

• CVE-2026-53053HIGH 8.8

  A flaw in AMD IOMMU (Input/Output Memory Management Unit) support within the Linux kernel can cause incorrect device isolation when handling PCI device aliases. The vulnerability stems from clone_alias() receiving the wrong device identifier, leading to stale or incorrect memory translation entries being copied to aliased devices. This breaks the isolation guarantees that IOMMUs provide, potentially allowing one device to access memory intended for another. The issue is present in how the kernel decides which device information to use when setting up DMA aliases across PCIe topologies.

• CVE-2026-53057HIGH 8.8

  A vulnerability in the Linux kernel's RISC-V IOMMU driver could allow a local attacker with basic user privileges to gain elevated access and affect system stability. The issue stems from missing cache invalidation operations after updating device and page directory table entries. When these tables are modified without proper invalidation, stale cached data can remain in the IOMMU's TLB and context cache, potentially allowing an attacker to bypass memory protections or cause system instability. This is a local attack vector requiring an account on the affected system, but the potential impact is significant because it can affect the confidentiality, integrity, and availability of data.

• CVE-2026-53071HIGH 8.8

  A vulnerability in the Linux kernel's Bluetooth L2CAP protocol implementation allows a malicious Bluetooth device to cause memory corruption and system instability. When a remote device sends a specially crafted L2CAP reconfiguration response, the kernel fails to properly protect a critical data structure (the channel list) from concurrent access. This can lead to a system crash, information disclosure, or potential privilege escalation. The flaw stems from a missing lock that should prevent simultaneous modifications and reads of the channel list, a synchronization pattern that was properly implemented in similar code paths but overlooked in this particular handler.

• CVE-2026-53072HIGH 8.8

  A locking bug in the Linux kernel's Bluetooth subsystem can lead to a use-after-free (UAF) vulnerability when handling incoming connection requests under specific conditions. When the kernel's Bluetooth protocol layer defers connection setup (a mechanism used by SCO and ISO protocols), a critical lock is not held during a function call that expects it, allowing concurrent code to delete connection objects while another code path is still using them. This can crash the system or potentially be exploited to gain elevated privileges on vulnerable systems.

• CVE-2026-53075HIGH 8.8

  A flaw in the Linux kernel's PPP (Point-to-Point Protocol) driver allows a local user without administrative privileges to perform privileged operations on network interfaces. The vulnerability exploits a gap in permission checking: while opening /dev/ppp is restricted to privileged users in one context, certain administrative commands can be issued against a different, inherited network namespace where the attacker has gained limited privileges. An attacker can create an isolated user namespace, become an administrator within that isolated space only, and then use that position to manipulate PPP network configuration in the main system namespace. The kernel now requires stricter permission validation to close this loophole.

• CVE-2026-53159HIGH 8.8

  A flaw exists in the Linux kernel's fastrpc driver that can corrupt memory addresses used for direct memory access (DMA) operations. When user-level code passes a pointer to the fastrpc subsystem, the kernel incorrectly calculates the corresponding DMA address if that pointer falls into a gap between memory regions. This miscalculation allows a local attacker to corrupt data sent to a specialized digital signal processor (DSP), potentially leading to privilege escalation or system compromise. The fix involves replacing an unsafe kernel function with a safer alternative that properly validates memory regions.

• CVE-2026-53170HIGH 8.8

  CVE-2026-53170 is a privilege escalation vulnerability in the Linux kernel's Arm Ethos-U NPU (neural processing unit) driver. A local attacker with basic user privileges can trigger unsafe DMA (direct memory access) operations by submitting incomplete hardware commands, allowing the NPU to read or write arbitrary physical memory locations. The flaw stems from an initialization check that fails when arithmetic overflow wraps a sentinel value, bypassing memory bounds validation.

• CVE-2026-53171HIGH 8.8

  A Linux kernel vulnerability in the Arm Ethos-U NPU driver's DMA length calculation function allows arithmetic wraparound to corrupt internal memory region size tracking. This corruption bypasses security checks that prevent invalid memory access, potentially enabling privilege escalation or system compromise on systems running vulnerable kernel versions with the Ethos-U accelerator driver loaded.

• CVE-2026-53188HIGH 8.8

  A vulnerability in the Linux kernel's RDMA core subsystem fails to properly validate device file operations when handling user capability requests. An attacker with local access could exploit character device aliasing—where a block device shares the same device number (dev_t) as a character device—to impersonate a legitimate RDMA user capability device and gain unauthorized access to privileged functions. The fix adds explicit validation of file operation pointers to ensure only authentic RDMA character devices are accepted.

• CVE-2026-53198HIGH 8.8

  A memory safety bug in the Linux kernel's ksmbd (kernel SMB daemon) file-locking code can be exploited to crash the system or potentially execute code. The vulnerability occurs when a network-connected attacker sends two specially-crafted SMB2 cancellation commands targeting the same lock request in rapid succession. This causes the kernel to access memory that has already been freed, leading to memory corruption. An attacker must be authenticated to the SMB service to exploit this issue.

• CVE-2026-53200HIGH 8.8

  A bug in the Linux kernel's KVM (Kernel Virtual Machine) hypervisor for ARM64 systems with nested virtualization support incorrectly grants execute permissions to memory regions that should be non-executable. The flaw stems from a misuse of a bitfield operation that was supposed to clear execute permissions but instead does the opposite. This affects systems running KVM nested virtualization on ARM64 processors without the XNX (Execute-Never eXtended) feature. An attacker with local access and the ability to create or manage virtual machines could exploit this to execute code in memory regions marked as non-executable, potentially breaking security boundaries between the hypervisor and guest virtual machines.

• CVE-2026-53232HIGH 8.8

  A resource cleanup bug in the Linux kernel's network PHY (physical layer) driver code can leave orphaned data structures in memory when the driver fails to initialize properly. Specifically, when an SFP (Small Form-factor Pluggable) module initialization encounters an error, the kernel fails to properly discard the upstream connection pointer, creating a dangling reference. This orphaned pointer can be mistakenly used in subsequent SFP-related events, potentially leading to memory corruption or unexpected behavior. The issue affects systems using network drivers that rely on the kernel's phylib SFP support, particularly those with hot-swappable fiber optic transceivers.

• CVE-2026-53240HIGH 8.8

  A use-after-free vulnerability exists in the Linux kernel's IPsec Tunnel Traffic Flow Security (IPTFs) reassembly logic. When handling fragmented packets, the code temporarily releases a lock and then checks whether a packet buffer is still owned by the reassembly state. Between the lock release and that check, another CPU or timer can complete reassembly and free the buffer, but the original code doesn't know this has happened. It then attempts to operate on the freed memory, causing a crash or potential code execution. The flaw requires an authenticated attacker to send specially crafted fragmented packets to a system with IPTFs enabled.

• CVE-2026-53248HIGH 8.8

  A use-after-free vulnerability exists in the Linux kernel's airoha network driver. When the driver tears down metadata destinations during cleanup, it frees memory immediately without waiting for all in-flight network packets to finish processing. If a packet is still referencing that freed memory, an attacker can trigger a crash or potentially execute code. The fix ensures proper memory synchronization by using the kernel's refcount and RCU (Read-Copy-Update) mechanism to defer memory deallocation until all active references are complete.

• CVE-2026-53266HIGH 8.8

  A vulnerability exists in the Linux kernel's network filtering bridge module where the SNAT (Source Network Address Translation) target fails to properly protect memory when rewriting ARP (Address Resolution Protocol) sender hardware addresses. The issue occurs when packet data is stored in non-contiguous memory fragments—particularly those backed by memory-mapped file pages. An attacker with local access could exploit this to write arbitrary data into kernel memory, potentially leading to privilege escalation or system compromise.

• CVE-2026-53275HIGH 8.8

  A memory safety flaw exists in how the Linux kernel processes IPv6 Multicast Listener Discovery (MLD) queries. When the kernel receives an MLD query packet, it saves a pointer to the multicast group address early in processing. However, later in the same function, the kernel may reallocate the packet buffer to add more data. After this reallocation, the saved pointer becomes invalid—it points to freed memory. If the code then tries to read from this invalid pointer, the kernel crashes or behaves unpredictably. An attacker on the same local network can send a specially crafted MLD query to trigger this condition, potentially causing a denial of service or worse.

• CVE-2026-53277HIGH 8.8

  CVE-2026-53277 is a synchronization bug in the Linux kernel's KVM (Kernel-based Virtual Machine) hypervisor for ARM64 systems. The vulnerability occurs when certain hypervisor operations that walk guest page tables fail to hold a required kernel lock (SRCU) that protects against concurrent memory slot changes. An attacker with local access and low privileges could exploit this race condition to cause memory corruption, information disclosure, or denial of service across privilege boundaries, including from a guest VM context into the host kernel.

• CVE-2026-53281HIGH 8.8

  A flaw in the Linux kernel's Intel VT-d IOMMU (Input/Output Memory Management Unit) driver can cause a crash or memory corruption when certain PASID (Process Address Space ID) teardown operations are performed incorrectly. The vulnerability stems from code that attempts to clean up device-PASID associations even when no valid association exists, leading to either dereferencing a NULL pointer or corrupting internal reference counts. This could allow a local attacker with basic user privileges to cause a denial of service or potentially escalate to higher impact by exploiting the memory corruption.

• CVE-2026-53322HIGH 8.8

  A timing vulnerability in the Linux kernel's VFIO (Virtual Function I/O) PCI driver creates a brief but exploitable window during device shutdown. When a PCIe function is disabled, the driver must revoke all direct memory access (DMABUF) mappings before clearing the Memory Space Enable (MSE) bit. If MSE is disabled first, a narrow race condition allows unprivileged local users to continue accessing device memory through existing DMABUF mappings even after the function should be inaccessible. This could lead to unauthorized data access, modification, or denial of service on systems where VFIO and DMABUFs are in active use.

• CVE-2026-53354HIGH 8.8

  A hardware vulnerability affecting certain Arm-based processors can cause memory writes to appear incomplete even after the CPU signals they are finished. When the kernel invalidates cached address translations (TLB entries), it issues a TLBI instruction followed by a memory barrier (DSB). On affected CPUs, this sequence may complete before all memory writes translated by the old TLB entry have been globally observed by other processors—a race condition that violates expected memory ordering. The Linux kernel resolves this by issuing the TLBI;DSB sequence twice, ensuring the first set of writes are fully observed before execution continues.

• CVE-2026-53358HIGH 8.8

  A lock-ordering vulnerability exists in the Linux kernel's Bluetooth L2CAP (Logical Link Control and Adaptation Protocol) implementation. When cleaning up listening channels, the kernel was acquiring locks in an unsafe sequence that could lead to deadlock or race conditions. The fix changes how channels are closed during cleanup—instead of closing them synchronously (which requires acquiring locks in the wrong order), the kernel now schedules them to be closed asynchronously through an existing timeout mechanism that acquires locks in the correct, established order. This prevents lock inversion and ensures channel cleanup happens safely without deadlock risk.

• CVE-2026-53359HIGH 8.8

  A use-after-free vulnerability exists in Linux kernel shadow paging when the kernel's memory management code encounters a specific sequence: a page directory entry (PDE) is modified from outside a guest VM, converting a 2MB page into 4KB pages, and then a memory slot is deleted. The kernel reuses an internal page structure (kvm_mmu_page) despite a mismatch in how that page should be configured, leading to corrupted memory tracking. When the memory is freed, dangling references to it remain and can be dereferenced by subsequent memory operations, causing a crash or potential privilege escalation. An unprivileged local user with KVM access can trigger this.

• CVE-2026-53360HIGH 8.8

  This Linux kernel vulnerability affects AMD SEV-SNP (Secure Encrypted Virtualization with Secure Nested Paging) virtual machines. A malicious guest operating system can exploit improper bounds checking in the Page State Change request handler to read and write memory outside the intended buffer boundaries. The attack allows the guest to leak sensitive information about the host kernel's memory layout and corrupt host kernel memory. The vulnerability requires the attacker to have already gained code execution within a virtual machine—it does not enable initial compromise of the host from an unprivileged network position.

• CVE-2026-53435HIGH 8.8

  Jenkins versions 2.567 and earlier (LTS 2.555.2 and earlier) contain a critical flaw in how they process configuration files. An authenticated attacker can craft a malicious `config.xml` file that causes Jenkins to deserialize and instantiate arbitrary Java objects from Jenkins core or installed plugins. Once deserialized, these objects can intercept and handle HTTP requests, enabling the attacker to impersonate any Jenkins user—including administrators—and perform actions such as accessing the Script Console to execute arbitrary code or reading sensitive files from the Jenkins controller.

• CVE-2026-53488HIGH 8.8

  containerd, a widely-used container runtime, has a flaw in how it handles metadata labels embedded in container images. When a container is launched from an image, labels defined in the Dockerfile (via LABEL instructions) are copied to the container without proper validation. A local attacker with user privileges could craft a malicious image with specially crafted labels that, when consumed by certain plugins, could lead to arbitrary command execution on the host system. The issue affects containerd versions before 1.7.33, 2.0.10, 2.1.9, 2.2.5, and 2.3.2.

• CVE-2026-53806HIGH 8.8

  OpenClaw before version 2026.5.12 has a vulnerability in how it parses shell command options. An attacker with authenticated access can combine shell flags in a way that tricks the system into running shell commands without proper validation. This bypasses security controls meant to restrict what commands can be executed, potentially allowing unauthorized command execution on systems where this feature is enabled.

• CVE-2026-53807HIGH 8.8

  OpenClaw versions before 2026.5.6 contain a flaw that allows authenticated users to bypass permission checks in Telegram interactive callbacks. An attacker with valid credentials can manipulate the callback mechanism to mark themselves as authorized before the allowlist validation occurs, effectively circumventing configured sender restrictions. This means an authenticated user could trigger commands they shouldn't be able to execute based on their Telegram sender status.

• CVE-2026-53810HIGH 8.8

  OpenClaw versions prior to 2026.5.18 allow attackers with operator-level access to manipulate how the marketplace loads extensions, causing it to run plugin code that hasn't been security-reviewed. The attacker can redirect the extension loader to fetch and execute code from unscanned packages, effectively bypassing the normal security controls that protect against malicious plugins. This affects users of OpenClaw who trust operators with administrative credentials.

• CVE-2026-53811HIGH 8.8

  OpenClaw versions before 2026.5.7 contain a privilege escalation flaw in how it handles the Matrix allowFrom feature. The vulnerability exists because the system trusts mutable display name metadata when matching policy rules. An authenticated user who can change their own display name can trick the access control system into granting them agent permissions intended for a different Matrix identity. The impact depends on what permissions operators have tied to those identities, but could range from lateral movement to unauthorized administrative access.

• CVE-2026-53817HIGH 8.8

  OpenClaw versions before 2026.5.22 contain a flaw in how the Control UI pairs devices and validates their location. An attacker with network access can fake locality information to trick the system into issuing admin-level credentials that persist even after token rotation. This converts temporary access into permanent administrative control, posing a significant risk to organizations using affected versions.

• CVE-2026-53819HIGH 8.8

  OpenClaw versions before 2026.5.27 allow attackers to execute arbitrary code on systems during the skill installation process. The vulnerability exists because workspace configuration files (.env) can be manipulated to point to malicious Homebrew-compatible executables. An attacker who has access to a trusted operator workspace can exploit this during skill setup to run unintended commands with the privileges of the OpenClaw process, effectively taking control of the system.

• CVE-2026-53821HIGH 8.8

  OpenClaw before version 2026.5.18 has a critical authorization flaw in its WebSocket implementation. The vulnerability allows unpaired or restricted Control UI clients to claim elevated operator.admin permissions without proper server validation. Once a WebSocket connection is established, an attacker can execute administrative Gateway RPCs (remote procedure calls) that should only be available to fully authorized administrators. The core issue is that the server accepts client-declared permission scopes before verifying the client's actual binding status or trusted-proxy authorization.

• CVE-2026-53822HIGH 8.8

  OpenClaw versions before 2026.5.18 contain a critical flaw that allows authenticated users to inject arbitrary shell commands by exploiting a timing gap between security approval and execution. An attacker with login credentials can craft malicious arguments that pass an initial security check, then modify them before the command runs—bypassing the allowlist protections meant to prevent unauthorized operations.

• CVE-2026-53828HIGH 8.8

  OpenClaw before version 2026.5.6 has a flaw that allows authenticated users to run commands that should only be available to the owner. Even though the software has built-in protections to prevent this, an attacker who has valid login credentials can bypass those protections and execute privileged commands they shouldn't have access to. This is particularly dangerous because it requires no user interaction and can be exploited over the network by anyone with basic authentication credentials.

• CVE-2026-53836HIGH 8.8

  OpenClaw versions before 2026.5.12 contain a security flaw in how they validate PowerShell commands. An authenticated attacker can bypass the system's command allowlist by using shortened aliases for PowerShell flags that the allowlist parser doesn't recognize. This allows them to execute arbitrary PowerShell code despite protections meant to prevent it. The vulnerability requires an attacker to already have valid credentials to the system.

• CVE-2026-53843HIGH 8.8

  OpenClaw before version 2026.5.26 has an authorization bypass flaw that lets attackers with previously paired devices regain administrative access to node systems even after administrators revoke their sessions. The vulnerability exploits a gap in how the system manages device pairing state—a surviving pairing credential can be weaponized to re-establish WebSocket authentication without triggering new approval workflows. This undermines revocation as a security control and extends the window of unauthorized access beyond the intended lockout period.

• CVE-2026-54099HIGH 8.8

  A vulnerability in Red Hat's Windows Machine Config Operator for OpenShift allows a compromised Windows worker node to escalate privileges to cluster administrator. The flaw exists in how the system validates certificate requests—it checks that requests contain a specific organization field (system:wicd-nodes) but fails to reject requests that also include additional organization values like system:masters. An attacker with access to WICD credentials on a Windows node can exploit this gap to obtain a certificate granting full cluster control.

• CVE-2026-54104HIGH 8.8

  A privilege escalation vulnerability exists in the U.S. Government Accountability Office's Electronic Protest Docketing System (EPDS) and the Civilian Board of Contract Appeals Electronic Docketing System (EDS). The systems fail to validate the 'epds_role_id' parameter on the server side, trusting values sent directly from users' browsers instead. This allows an authenticated user—someone with legitimate access—to modify this parameter and assume higher privilege roles than their account should allow, such as gaining administrative capabilities. The vulnerability requires an attacker to already have valid login credentials, but once authenticated, no additional barriers prevent the privilege escalation.

• CVE-2026-5411HIGH 8.8

  WP Captcha PRO, a WordPress security plugin, contains a flaw that allows attackers with basic user accounts to upload and execute malicious code on affected websites. The vulnerability stems from insufficient validation when the plugin downloads and extracts files as part of its cloud protection feature. An attacker can trick the plugin into downloading a malicious archive, which it will extract into a publicly accessible folder, enabling remote code execution. This requires the attacker to have at least Subscriber-level access to WordPress and depends on certain PHP server configurations being enabled.

• CVE-2026-54149HIGH 8.8

  MaxKB, an open-source AI assistant platform for enterprises, contains a vulnerability that allows authenticated users to execute arbitrary system commands on the server. An attacker with valid credentials can craft a malicious tool file (.tool) and import it through the platform's tool import feature. When that tool is subsequently triggered via an AI Chat node, the system will execute arbitrary operating system commands with the privileges of the MaxKB process. This requires the attacker to already have user authentication credentials and knowledge of how to structure a malicious MCP (Model Context Protocol) transport configuration.

• CVE-2026-5415HIGH 8.8

  WP Captcha PRO, a WordPress plugin used for reCAPTCHA integration, contains a critical flaw that allows attackers with basic user access to impersonate any account on the site, including administrators. The vulnerability chains together three separate weaknesses: the plugin exposes a security token to low-privilege users, uses that token in an unprotected function that generates passwordless login links, and then automatically logs in visitors using those links without verifying they should have access. An attacker with even Subscriber-level access (the lowest user role) can exploit this to take over any account and gain full control of the WordPress installation.

• CVE-2026-5416HIGH 8.8

  A command injection vulnerability exists in Managed Ethernet Switch devices that allows an authenticated attacker with low-level privileges to inject malicious commands through an improperly validated name parameter. An attacker exploiting this flaw can execute arbitrary system commands and achieve complete control over the affected device. The vulnerability requires valid login credentials to trigger, but does not require user interaction once authenticated.

• CVE-2026-54232HIGH 8.8

  vLLM, a popular inference engine for large language models, has a critical supply-chain vulnerability in versions before 0.22.1. The Dockerfile attempts to install a custom package (flashinfer-jit-cache) from a private index, but misconfigures Python's package resolution to also search PyPI. An attacker could register a malicious version of that package on PyPI, which would be installed during container builds with full root privileges. This allows arbitrary code execution and container backdooring, potentially compromising all prompts, credentials, and model data in production deployments.

• CVE-2026-54404HIGH 8.8

  A vulnerability in Ubiquiti UniFi OS allows attackers who already have network access and low-level user credentials to run specially crafted SQL commands that bypass normal security controls and gain administrative privileges. This affects a broad range of UniFi networking and video recording devices. An attacker would need existing credentials to exploit this—they cannot attack from outside the network or without logging in first.

• CVE-2026-54469HIGH 8.8

  Dell Unisphere for PowerMax versions 10.3.0.5 and earlier contain a flaw that allows a low-privileged attacker with remote access to execute arbitrary commands as root. The vulnerability stems from unsafe handling of serialized data, meaning an attacker can craft malicious input that, when deserialized by the application, triggers code execution at the highest privilege level. This is a critical escalation path: an attacker who gains even basic user access can weaponize this flaw to take complete control of the storage management infrastructure.

• CVE-2026-54639HIGH 8.8

  Style Dictionary, a widely-used build tool for managing design tokens across platforms, contains a prototype pollution vulnerability that allows attackers to inject malicious properties into JavaScript objects through specially crafted token data. The flaw affects versions 4.3.0 through 5.4.3 and is particularly dangerous when Style Dictionary processes tokens in server-side Node.js applications, where an attacker with the ability to modify token inputs could corrupt application state or behavior. Organizations using this library should update to version 5.4.4 or later immediately if they process untrusted or externally-sourced token data.

• CVE-2026-54998HIGH 8.8

  Microsoft Exchange Online contains a flaw in how it validates user permissions, allowing someone with legitimate access to the system to gain higher privileges than they should have. An attacker with any valid Exchange Online account could exploit this over the network to gain administrator-level capabilities, potentially compromising email data, modifying configurations, and accessing sensitive organizational information.

• CVE-2026-55114HIGH 8.8

  CVE-2026-55114 is a privilege escalation flaw in Ubiquiti's UniFi Network Application that allows an authenticated attacker with low-level permissions to gain higher privileges within the application. An attacker already present on the network can exploit weak access controls to expand their capabilities and potentially compromise network infrastructure management.

• CVE-2026-55207HIGH 8.8

  Pimcore, an open-source data and experience management platform, contains a critical flaw that allows attackers to hijack administrator accounts without knowing the original password. An unauthenticated attacker who knows a valid admin username can exploit a password reset feature by supplying a malicious URL. The system generates a legitimate recovery token, appends it to the attacker's URL, and emails the link to the admin. When the admin clicks the link, the token is unwittingly sent to the attacker, who can then use it to log in with full administrative privileges—bypassing two-factor authentication entirely. This attack requires social engineering (the admin must click the link) but is otherwise trivial to execute.

• CVE-2026-5523HIGH 8.8

  The Divi Form Builder plugin for WordPress allows authenticated users with the lowest privilege level (subscribers) to hijack any account on the site, including administrator accounts. An attacker with subscriber access can submit a specially crafted form to change another user's email address and password, effectively locking out the legitimate owner. This bypasses WordPress's normal permission checks, which should prevent users from modifying accounts they don't own.

• CVE-2026-55237HIGH 8.8

  AutoGPT versions before 0.6.62 contain a DOM-based cross-site scripting (XSS) vulnerability in the signup page. An attacker can craft a malicious link that tricks an authenticated user into clicking it, then executes arbitrary JavaScript in the victim's browser. This happens because the application unsafely uses a URL parameter called `next` to redirect users without properly validating it. Once the attacker's code runs, they could steal login credentials, access internal systems, or perform actions as if they were the victim.

• CVE-2026-55607HIGH 8.8

  Claude Code versions 2.1.38 through 2.1.162 contain a sandbox escape vulnerability that allows attackers to execute arbitrary code on a user's machine outside the seatbelt sandbox. The flaw stems from improper handling of git worktrees, which can be manipulated to create directories named ".git" and access files outside the intended sandbox boundaries. An attacker can exploit this by hosting a malicious repository containing prompt injection content; when a user clones the repository and runs Claude Code against it, symlink manipulation and git fsmonitor execution during worktree operations can overwrite critical shell configuration files (such as .zshenv) in the user's home directory, achieving code execution with the user's privileges.

• CVE-2026-55698HIGH 8.8

  pnpm, a popular Node.js package manager, contains a vulnerability in versions before 10.34.2 and 11.5.3 that allows malicious repositories to inject and execute arbitrary code during package manager installation. The issue stems from pnpm's trust in cached package-manager metadata within the pnpm-lock.yaml file. When a repository commits a specially crafted lockfile with matching pnpm and @pnpm/exe versions, pnpm may skip fresh resolution of the package manager itself and instead execute code from the attacker-controlled lockfile during automatic version switching. An attacker would need to trick a developer into cloning and running commands in a malicious repository, but no special credentials or authenticated access is required.

• CVE-2026-55738HIGH 8.8

  CVE-2026-55738 is a stack buffer overflow vulnerability in rxi microtar 0.1.0, a lightweight TAR archive parsing library. The flaw exists in how the library handles TAR header fields that contain no null terminators. When a crafted TAR file is opened or parsed, an attacker can trigger out-of-bounds memory reads and writes that crash the application or potentially execute arbitrary code. The vulnerability requires user interaction (opening or parsing a malicious archive) but carries high risk due to the nature of memory corruption exploits.

• CVE-2026-55741HIGH 8.8

  Cotonti 1.0.0 contains a Cross-Site Request Forgery (CSRF) vulnerability in its administration panel configuration handler. When an authenticated administrator visits a malicious webpage, an attacker can trick the browser into sending forged requests that modify core system settings, module configurations, or plugin options without the administrator's knowledge or consent. Unlike other administrative functions in Cotonti, the configuration update handler does not validate the anti-CSRF token before processing changes, leaving it exposed to this attack vector.

• CVE-2026-56010HIGH 8.8

  A privilege escalation vulnerability exists in Abandoned Cart Pro for WooCommerce versions 10.4.0 and earlier. An authenticated attacker with subscriber-level permissions can escalate their privileges within the plugin, gaining unauthorized access to administrative functions and sensitive data. This affects WooCommerce sites using this e-commerce recovery plugin.

• CVE-2026-56037HIGH 8.8

  Themify Popup versions through 1.4.3 contain a deserialization vulnerability that allows authenticated attackers to inject malicious objects into the application. An attacker with user credentials can craft a specially formatted request that causes the plugin to deserialize untrusted data, leading to arbitrary code execution and full system compromise. This is a high-severity flaw requiring immediate patching.

• CVE-2026-56075HIGH 8.8

  PraisonAI versions before 4.5.128 have a critical flaw that allows authenticated users to trick the system into running arbitrary shell commands on the server. The vulnerability stems from a hardcoded setting that forces automatic approval of commands, even when administrators have configured the system to require manual review. An attacker with login credentials can exploit this by instructing the AI agent to execute dangerous shell commands, bypassing both the approval safeguard and command filtering protections.

• CVE-2026-56078HIGH 8.8

  PraisonAI versions before 1.5.115 contain a critical flaw in the MultiAgentMonitor component that allows authenticated users to access, modify, or destroy files anywhere on the system. The vulnerability stems from insufficient validation of agent IDs—the text strings that identify different agents in the system. By injecting path traversal sequences (like ../) into an agent ID, an attacker with valid credentials can navigate outside the intended directory and interact with sensitive files. This could lead to data theft, system crashes, or potentially executing malicious code on the affected server.

• CVE-2026-56086HIGH 8.8

  Dell PowerProtect Data Domain contains a flaw in how it checks user permissions. A remote attacker with low-level credentials can bypass authorization controls and gain unauthorized access to the system. This affects multiple versions across different release lines (7.7 through 8.6 and several LTS branches). The vulnerability allows a low-privileged user to escalate their access in ways the system should prevent.

• CVE-2026-56115HIGH 8.8

  Bootimus versions up to 0.1.70 suffer from a privilege escalation vulnerability that allows low-privileged authenticated users to perform administrative actions without proper authorization. The flaw exists in the JWT token validation logic, which checks whether a user is logged in and has an active account, but neglects to verify whether that user holds administrator rights. An attacker with legitimate access can exploit this gap to create new admin accounts or reset existing administrator passwords, effectively taking over the entire Bootimus server. This is particularly dangerous because Bootimus serves boot menus and installation scripts to PXE clients—meaning an attacker could modify the operating system images or scripts deployed across your infrastructure.

• CVE-2026-56216HIGH 8.8

  Capgo versions before 12.128.2 contain a privilege escalation flaw that allows attackers who compromise an app-limited API key to escalate it into a fully unrestricted key with organization-wide access. The vulnerability exists in the API key minting endpoint and can be exploited by setting empty permission limits during key creation. This means an attacker with a limited-scope key could gain access to sensitive resources across the entire organization, including app listings and other protected endpoints.

• CVE-2026-56230HIGH 8.8

  Capgo versions before 12.128.2 contain an authorization flaw that allows authenticated users to impersonate other tenants' API keys. The vulnerability stems from the middlewareKey() function accepting a client-supplied header (x-limited-key-id) without checking whether the authenticated user actually owns that key. This enables lateral movement across tenant boundaries, letting an attacker access data and resources belonging to other organizations sharing the same Capgo instance.

• CVE-2026-56232HIGH 8.8

  Capgo, a cloud deployment platform, contains a critical authentication bypass vulnerability in how it validates API key permissions. The vulnerability allows authenticated users to circumvent restrictions placed on limited-scope API keys (subkeys) by manipulating the x-limited-key-id header. Instead of enforcing the intended scope constraints, the application defaults to using the unrestricted parent key for all subsequent operations. This means an attacker with a scoped subkey can effectively gain the full permissions of their parent account, potentially accessing or modifying any organization or application they shouldn't have access to.

• CVE-2026-56247HIGH 8.8

  Capgo versions before 12.128.2 contain a role-based access control (RBAC) vulnerability that allows organization administrators to bypass security restrictions. An admin can assign powerful organization-level roles to users at the app level without proper validation, and critically, can do this to people who haven't yet accepted their invitations. When those invited users later accept and join, they retain these elevated permissions—even though they were only supposed to have limited app-level access. This means a low-privilege user could suddenly perform high-privilege actions they should never be allowed to do.

• CVE-2026-56340HIGH 8.8

  vLLM, a popular open-source framework for large language model inference, contains a validation gap in how it handles tensor data for multimodal embeddings. Versions 0.10.2 through 0.12.x fail to properly validate tensor indices when the prompt-embeddings feature is active. An authenticated attacker can send specially crafted embedding requests with invalid tensor indices (negative or out-of-bounds values) to crash the service, exhaust resources, or potentially corrupt memory. This is a follow-up to an earlier vulnerability (CVE-2025-62164) where the fix only disabled the feature by default rather than validating the input itself.

• CVE-2026-56396HIGH 8.8

  phpMyFAQ versions before 4.1.4 contain a privilege escalation vulnerability in user management endpoints. An authenticated administrator account with basic user-editing permissions can exploit missing authorization checks to promote themselves or other accounts to SuperAdmin level, bypassing the intended role hierarchy. This requires an attacker to already have legitimate admin access, but the vulnerability allows them to exceed their assigned privileges.

• CVE-2026-56423HIGH 8.8

  MISP Core contained authorization flaws in bulk deletion operations for Event Reports and Sharing Groups. Rather than verifying that a user owned or had explicit permission to delete each selected item, the system only checked whether the user held a broad role-level permission (such as 'contributor' or 'sharing group capable'). An authenticated attacker could exploit this to delete Event Reports or Sharing Groups belonging to other organizations, causing permanent loss of data or configuration across the entire MISP instance.

• CVE-2026-56424HIGH 8.8

  MISP, a widely-used threat intelligence sharing platform, contained multiple authorization flaws that allowed authenticated users to modify or delete data belonging to other organizations. Instead of checking whether a user owned the data they were trying to change, the application sometimes checked permissions against the wrong object or skipped the ownership check entirely. This meant a user with basic access could tamper with event reports, intelligence collections, analyst notes, templates, and decay models belonging to competitors or other organizations—potentially corrupting shared threat intelligence and disrupting security teams' workflows.

• CVE-2026-56425HIGH 8.8

  Azure Active Directory (AAD) Authentication Plugin for MISP contains serious flaws in how it handles OAuth 2.0 login flows. The plugin reuses PHP session identifiers as OAuth security tokens, which can leak through browser history and server logs—allowing attackers to steal active sessions. It also fails to rotate session IDs after login, leaves the authentication process vulnerable to replay attacks, permits unencrypted OAuth callbacks, and logs sensitive error data without sanitization. Together, these weaknesses could let an attacker hijack user sessions, forge login credentials, or tamper with audit records.

• CVE-2026-56645HIGH 8.8

  Microsoft Edge (Chromium-based) contains a heap-based buffer overflow vulnerability that allows attackers to execute arbitrary code remotely. The vulnerability requires user interaction—such as visiting a malicious webpage or opening a crafted document—but does not require authentication. Once triggered, an attacker gains the same privileges as the user running the browser, potentially enabling credential theft, malware installation, or lateral movement within a network.

• CVE-2026-56766HIGH 8.8

  Hydra, a popular password-cracking tool, contains a critical flaw in how it handles authentication with certain server types. When a malicious server sends a specially crafted authentication challenge during login attempts to email or web services, it can trigger a memory overflow in Hydra's process. This could allow an attacker to execute arbitrary code on a system running a vulnerable version of Hydra. The vulnerability affects Hydra versions through 9.7 and has been patched in a later commit.

• CVE-2026-56767HIGH 8.8

  Maxun versions before 0.0.42 suffer from a cross-tenant access control bypass that lets any authenticated user view and manipulate other users' automation robots and stored API credentials. An attacker with legitimate access to the platform can read plaintext Google and Airtable tokens belonging to other accounts, modify or delete their workflows, and execute their robots without permission. This is a direct result of missing ownership verification in the API layer.

• CVE-2026-56768HIGH 8.8

  Seahub versions before 13.0.23 contain an authentication bypass vulnerability in their file-sharing API. When a user shares a folder via link, the system should require login for access—but this check is missing on one specific endpoint. An attacker who obtains a share-link token can use it to request a download of the entire shared folder as a ZIP file without authenticating, even if the share was restricted to logged-in users only. This allows unauthorized bulk extraction of sensitive data from what administrators believed was a protected share.

• CVE-2026-56773HIGH 8.8

  Teable's v2 REST API has a flaw where certain endpoints don't enforce proper permission checks. This means any user with basic access to a Teable instance can read sensitive table structures, create new tables, and modify or delete data across the entire system—far beyond what their role should allow. The vulnerability stems from missing permission metadata on API handlers, letting requests slip through without authorization validation.

• CVE-2026-56841HIGH 8.8

  An authenticated SQL injection vulnerability in UniFi Protect allows a user or attacker with valid network access and low-level privileges to execute arbitrary SQL commands against the application's database. By manipulating SQL queries through the application interface, an attacker can bypass security controls and gain elevated permissions on the host device running UniFi Protect. This is a post-authentication attack; the attacker must already have some form of access to the system or network.

• CVE-2026-57280HIGH 8.8

  Jenkins Script Security Plugin versions up to 1402.v94c9ce464861 contain a sandbox bypass vulnerability that allows authenticated attackers to execute arbitrary code. The flaw stems from incomplete type-cast handling in Groovy for-each loops, which permits attackers to invoke constructors that should be restricted by the sandbox. An attacker with script-execution privileges can exploit this to escape the plugin's security controls and run arbitrary Java constructors on the Jenkins server.

• CVE-2026-57296HIGH 8.8

  Jenkins users running the External Workspace Manager Plugin versions 1.3.2 and earlier face a critical security gap: the plugin fails to block path traversal attacks in the custom workspace path field. An attacker with permission to configure a Jenkins job can exploit this to read sensitive files from the Jenkins server itself—potentially including credentials, configuration files, and secrets—and in some scenarios escalate to remote code execution. The vulnerability requires valid Jenkins access but poses severe risk to organizations relying on Jenkins for CI/CD automation.

• CVE-2026-57301HIGH 8.8

  Jenkins users with the OWASP ZAP Plugin version 1.0.7 or earlier should be aware of a code execution vulnerability. The plugin is designed to run security scans on distributed Jenkins agents, but a flaw causes it to execute on the Jenkins controller itself instead. An attacker who has permission to configure Jenkins jobs can exploit this to run arbitrary code directly on your Jenkins controller—the central system that orchestrates all builds. This is particularly dangerous because the controller typically has broad access to credentials, source code, and other sensitive infrastructure.

• CVE-2026-57516HIGH 8.8

  Ray versions before 2.56.0 contain a critical vulnerability in how they process web dataset files. When using the read_webdataset() function, Ray automatically unpacks and deserializes certain file types (pickle and PyTorch model files) from tar archives without validation. An attacker can craft a malicious archive containing specially crafted .pkl, .pickle, .pt, or .pth files that execute arbitrary code when processed. Because Ray distributes this work across remote workers, the malicious code runs on every worker that touches the archive, potentially compromising your entire distributed computing cluster.

• CVE-2026-57518HIGH 8.8

  Pagekit CMS versions up to 1.0.18 contain a privilege escalation flaw that allows authenticated users with user management permissions to grant themselves elevated access rights. Once elevated, attackers can install malicious PHP packages through the system's admin installer, leading to complete system compromise. The vulnerability requires initial authentication but chains to remote code execution with minimal difficulty.

• CVE-2026-57527HIGH 8.8

  Zed Attack Proxy (ZAP), a widely-used security testing tool, contains a critical vulnerability in its ViewState add-on that allows attackers to run arbitrary code on a security analyst's machine. The flaw exists because the add-on deserializes untrusted data from web server responses without proper validation. An attacker who controls or compromises a proxied web server can craft a malicious response that executes code within ZAP itself when an analyst uses the tool to inspect the response. This is particularly concerning because ZAP is trusted to test web applications—turning it into an attack vector undermines that trust.

• CVE-2026-57659HIGH 8.8

  A vulnerability in Paid Memberships Pro version 0.7.2 and earlier allows an attacker to trick an administrator into performing unintended actions without their knowledge or consent. By crafting a malicious webpage or email, an attacker can force a logged-in admin to unwittingly create, modify, or delete member accounts. The attack requires no special access or authentication—only that the target admin visits a compromised link while logged into the WordPress admin panel.

• CVE-2026-5768HIGH 8.8

  The Frontier X2 wearable device has a critical Bluetooth security flaw that allows attackers within radio range to control the device and manipulate health data without any authentication. An attacker can start or stop activities, trigger unwanted vibrations, inject fake health readings like heart rate and breathing data into the companion mobile app, or disrupt the device entirely. The mobile app itself also fails to properly authenticate Frontier X2 devices, enabling attackers to create fake devices that the app will trust, further expanding the attack surface.

• CVE-2026-57766HIGH 8.8

  WPIDE – File Manager & Code Editor versions 3.5.6 and earlier contain an unauthenticated cross-site request forgery (CSRF) vulnerability. An attacker can craft a malicious webpage or email that, when visited by a logged-in WordPress administrator, tricks their browser into performing unwanted actions within WPIDE without their knowledge or consent. Because the plugin fails to validate the source of requests, an unauthenticated attacker can leverage this to modify files, execute code, or alter plugin settings.

• CVE-2026-57974HIGH 8.8

  Microsoft Edge (the Chromium-based browser) contains an integer overflow flaw that allows an attacker to execute arbitrary code on a victim's computer by sending specially crafted network traffic. The vulnerability requires user interaction—such as visiting a malicious website or opening a compromised link—but once triggered, grants the attacker full code execution capabilities on the affected system.

• CVE-2026-57981HIGH 8.8

  Microsoft Edge (Chromium-based) contains a use-after-free vulnerability that allows attackers to execute arbitrary code on a user's system when they visit a malicious website. The flaw requires user interaction—specifically, the victim must visit a compromised or attacker-controlled web page—but once triggered, an unauthenticated attacker can gain full code execution with the privileges of the Edge browser process. This is a network-based attack with no special privileges required on the attacker's side.

• CVE-2026-57995HIGH 8.8

  phpMyFAQ versions before 4.1.5 contain a privilege escalation flaw in how it handles group permission updates. An administrator with limited GROUP_EDIT rights can exploit a validation gap to assign themselves powerful permissions they shouldn't possess, potentially escalating to full admin control. The vulnerability requires an authenticated account but no special interaction from other users.

• CVE-2026-57999HIGH 8.8

  A command injection flaw in the luci-app-tailscale-community package allows any authenticated user to run arbitrary commands with root privileges. The vulnerability stems from improper handling of login server parameters in the Tailscale RPC method—specifically, user-supplied values are embedded in a shell command without proper escaping, enabling shell metacharacters like $() to break out and execute attacker-controlled code.

• CVE-2026-58000HIGH 8.8

  A command injection vulnerability exists in luci-proto-openvpn versions up to 0.11.1 that allows authenticated LuCI users with OpenVPN configuration access to execute arbitrary commands with root privileges. The vulnerability stems from improper handling of the cl_meta parameter in the generateKey ubus method, where user input is directly interpolated into a shell command without sanitization. An attacker with valid LuCI credentials can exploit this to gain complete control over the affected system.

• CVE-2026-58143HIGH 8.8

  Cotonti Siena versions 0.9.26 and earlier contain a CSRF vulnerability in the admin configuration handler. An attacker can trick a logged-in administrator into visiting a malicious webpage or clicking a crafted link, which silently modifies admin settings. Specifically, the attacker can disable the file extension whitelist in the PFS (file upload) module, allowing any user with upload access to execute arbitrary PHP code on the server. The vulnerability exists because the admin.php config update endpoint fails to validate CSRF tokens before accepting configuration changes.

• CVE-2026-58165HIGH 8.8

  OpenZiti, a zero-trust networking platform, contains a privilege escalation flaw that allows authenticated users with enrollment management permissions to impersonate administrators. An attacker with these limited permissions can trick the system into issuing administrative credentials, effectively hijacking the entire network controller and gaining full control over the zero-trust overlay. The vulnerability exists because the system fails to verify that an enrollment request comes from someone authorized to act on behalf of the target identity.

• CVE-2026-58168HIGH 8.8

  DeepTutor before version 1.4.10 has a flaw that lets low-privilege users run any tool connected to the system without proper authorization checks. When a system administrator forgets to explicitly deny access to certain tools (Model Context Protocol or MCP tools), the software defaults to allowing everything instead of blocking access. This means an attacker or malicious prompt inside a user's session can use any available tool—like accessing files, running shell commands, or controlling a browser—potentially compromising sensitive data and system integrity.

• CVE-2026-58253HIGH 8.8

  NATS Server, a messaging platform used in cloud and edge computing environments, contains an authentication bypass vulnerability in versions prior to 2.14.0, 2.12.7, and 2.11.16. When a fallback authentication user (no_auth_user) is configured, the server incorrectly applies a performance optimization meant for regular client connections to inter-server routes and leaf node connections. This allows an unauthenticated attacker on the network to connect as a privileged peer and potentially read data, modify configurations, or disrupt services. Organizations running vulnerable NATS deployments should prioritize upgrades to patched versions.

• CVE-2026-58378HIGH 8.8

  The Allwinner H616 TV Box TV98 ships with Android Debug Bridge (ADB) enabled and accessible over the network in production deployments. An attacker on the network can request ADB authorization and, if the user grants access, obtain complete root-level control of the device. This is a network-exposed debug interface that should never be enabled in consumer products.

• CVE-2026-58452HIGH 8.8

  JAIOTlink C492A-W6 Wi-Fi IP cameras contain a command injection flaw in their firmware that allows attackers who have valid login credentials to execute arbitrary system commands on the device. The vulnerability exists in the network configuration endpoint and can be triggered by crafting a specially formatted network parameter. An attacker with authenticated access could use this to gain complete control over the camera, potentially enabling lateral movement into the broader network infrastructure.

• CVE-2026-59093HIGH 8.8

  Weaviate has a privilege escalation vulnerability in its role-based access control (RBAC) system. When assigning roles to users or groups, the system fails to check whether the person doing the assigning actually has the permissions they're trying to grant. This means someone with only basic role-assignment permissions can give themselves or others the admin role, effectively taking over the entire database. The issue exists in versions before 1.38.0.

• CVE-2026-59148HIGH 8.8

  Mockoon, a tool for designing and running mock APIs, contains a critical flaw in its administrative interface that leaves it wide open to unauthorized access and manipulation. The admin API—which is enabled by default and runs on the same port as user-defined mock routes—accepts requests from any source without requiring authentication or checking the caller's identity. An attacker who can reach the mock server port can steal environment variables containing sensitive configuration data, modify how the mock API behaves by rewriting routes and responses, access transaction logs, and disrupt service availability. The vulnerability was introduced in the default configuration and is resolved in version 9.7.0.

• CVE-2026-59257HIGH 8.8

  n8n versions before 1.123.61, 2.27.4, and 2.28.1 are vulnerable to SQL injection through the legacy MySQL v1 node when it processes user-controlled input in SQL queries. If an n8n workflow connects an externally-accessible trigger (like a Webhook) to a MySQL v1 operation, an attacker can inject malicious SQL commands that execute with the privileges of the configured database account. The newer MySQL v2 node is not affected because it properly isolates SQL code from user input.