By severity

High-severity vulnerabilities

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

4140 published vulnerabilities · page 15 of 42

• CVE-2025-71341HIGH 8.1

  Picklescan, a tool designed to scan Python pickle files for malicious code, has a detection bypass vulnerability in versions before 0.0.29. An attacker can craft a malicious pickle file that uses the profile.Profile.runctx function in a way that picklescan fails to detect, allowing arbitrary code execution when the file is unpickled. This is particularly dangerous because picklescan is often relied upon as a security control to prevent exactly this kind of attack.

• CVE-2025-71342HIGH 8.1

  A security detection tool called picklescan has a blind spot that allows attackers to hide malicious code in Python pickle files. Pickle is a serialization format widely used in machine learning frameworks like PyTorch. When someone opens a booby-trapped pickle file with standard Python code, the hidden malicious instructions execute automatically, giving the attacker remote code execution. Because picklescan versions before 0.0.30 miss this specific attack pattern—using a Python module called idlelib.run.Executive—the tool cannot warn users that a pickle file is dangerous, making it an effective supply chain weapon against organizations that rely on pre-trained ML models from untrusted sources.

• CVE-2025-71343HIGH 8.1

  picklescan, a security tool designed to detect malicious pickle files before they're loaded, contains a detection bypass in versions before 0.0.30. Attackers can craft specially constructed pickle files that exploit a function in Python's lib2to3 library to execute arbitrary code while evading picklescan's safety checks. The vulnerability is triggered when a user or application calls pickle.load() on a crafted malicious file, making it a supply-chain and deserialization risk for organizations relying on picklescan for protection.

• CVE-2025-71344HIGH 8.1

  picklescan is a security scanning tool designed to detect malicious code hidden in pickle files before they're loaded by Python applications. However, versions 0.0.26 and earlier have a critical blind spot: they fail to recognize the ensurepip._run_pip function when embedded in pickle files. Attackers can exploit this gap by crafting malicious pickle files that call ensurepip._run_pip through __reduce__ methods—a standard pickle deserialization hook. When an application using vulnerable picklescan loads such a file, the malicious code executes without triggering any security alert, giving attackers arbitrary code execution on the system.

• CVE-2025-71345HIGH 8.1

  Picklescan is a security tool designed to detect and block malicious Python pickle files before they are deserialized. A gap has been discovered in versions prior to 0.0.30: the tool fails to identify pickle files that exploit the torch.utils.bottleneck.__main__.run_autograd_prof function, a PyTorch utility typically used for performance profiling. Attackers can weaponize this oversight by embedding code in pickle files that executes when the file is unpickled, potentially leading to remote code execution on systems that use picklescan as their defense mechanism. This is particularly dangerous because organizations relying on picklescan may believe they are protected when they are not.

• CVE-2025-71347HIGH 8.1

  Picklescan, a Python security tool designed to detect malicious code in pickle files before they're loaded, has a gap in its detection logic. Versions before 0.0.33 miss a specific attack technique that uses NumPy's internal fortran parsing code (numpy.f2py.crackfortran.param_eval) hidden in pickle serialization instructions. An attacker can craft a pickle file that runs arbitrary code when an application deserializes it—and picklescan won't flag it as dangerous. This means if your organization relies on picklescan to safely handle untrusted pickle data, you need to update immediately.

• CVE-2025-71348HIGH 8.1

  A vulnerability in picklescan, a Python library designed to detect malicious pickle files, allows attackers to bypass its safety checks by embedding code that specifically leverages torch.utils._config_module.load_config within pickle reduce methods. When an unsuspecting user loads such a crafted pickle file, the embedded code executes as if the file were benign, potentially giving attackers a foothold in supply chain scenarios where picklescan is relied upon as a gatekeeper.

• CVE-2025-71349HIGH 8.1

  CVE-2025-71349 is a vulnerability in picklescan, a security tool designed to detect dangerous code embedded in Python pickle files. The flaw allows attackers to hide malicious code using Python's built-in trace.Trace.run function, which picklescan versions before 0.0.29 fail to recognize. When someone opens a specially crafted malicious pickle file with Python's pickle.load function, the hidden code runs automatically, giving the attacker control over the affected system. The vulnerability requires user interaction—someone must open the malicious pickle file—but once they do, the attacker gains full code execution capabilities.

• CVE-2025-71350HIGH 8.1

  Picklescan, a security tool designed to detect malicious Python pickle files, contains a bypass vulnerability that allows attackers to hide malicious code within pickle files. The vulnerability specifically involves the torch.utils.collect_env.run function, which picklescan fails to properly inspect when used in reduce methods. An attacker can craft a pickle file that executes arbitrary remote commands when a victim loads it, bypassing picklescan's detection. This is particularly dangerous because picklescan is often relied upon as a safety gate before deserializing untrusted pickle data.

• CVE-2025-71352HIGH 8.1

  picklescan is a security tool designed to inspect Python pickle files for malicious code before they are deserialized. A vulnerability in picklescan before version 0.0.29 allows attackers to bypass its detection mechanisms by using the built-in Python trace.Trace.runctx function within pickle reduce methods. When a user loads a specially crafted malicious pickle file, the code executes without triggering picklescan's safety checks, potentially compromising systems that rely on picklescan for pickle validation.

• CVE-2025-71353HIGH 8.1

  Picklescan, a Python security tool designed to scan pickle files for malicious content, contains a detection bypass vulnerability in versions before 0.0.28. Attackers can craft specially designed pickle files that exploit a specific function in PyTorch's torch._dynamo.guards.GuardBuilder to hide malicious code. When these files are loaded by applications relying on picklescan for protection, the malicious payload executes despite the tool's screening, potentially giving attackers full command execution on affected systems.

• CVE-2025-71354HIGH 8.1

  picklescan, a security tool designed to detect malicious Python pickle files before they're executed, has a detection bypass vulnerability. Versions before 0.0.29 fail to recognize pickle files that abuse the idlelib.debugobj.ObjectTreeItem.SetText function within pickle reduce methods. An attacker can craft a malicious pickle file that passes picklescan's safety checks but executes arbitrary commands when loaded with pickle.load(), defeating the tool's intended protective purpose.

• CVE-2025-71356HIGH 8.1

  Picklescan, a tool designed to detect malicious code in Python pickle files, has a critical blind spot. Versions before 0.0.28 fail to recognize a specific attack pattern involving PyTorch's symbolic shape evaluation function. Attackers can weaponize this gap by embedding code that looks clean to picklescan but executes arbitrary commands when the pickle file is opened—a classic remote code execution scenario that puts any organization deserializing untrusted pickles at serious risk.

• CVE-2025-71357HIGH 8.1

  Picklescan, a Python library designed to detect malicious pickle files, has a detection bypass vulnerability in versions before 0.0.30. Attackers can craft pickle files that leverage Python's idlelib.pyshell.ModifiedInterpreter.runcommand function within reduce methods to execute arbitrary remote commands on systems that load the file. The vulnerability exists because picklescan fails to recognize this specific code execution path as dangerous, allowing malicious payloads to slip through security checks.

• CVE-2025-71358HIGH 8.1

  picklescan, a tool designed to scan pickle files for malicious content, contains a detection bypass flaw affecting versions before 0.0.29. The vulnerability allows attackers to craft malicious pickle files that evade picklescan's security checks by exploiting a specific function in Python's idlelib library. When victims use Python's standard pickle.load() to open these seemingly-safe files, arbitrary code executes on their systems. This is particularly dangerous because picklescan is often deployed as a safety gate—organizations rely on it to vet untrusted pickle data, making this bypass a fundamental breach of that trust.

• CVE-2025-71359HIGH 8.1

  picklescan is a Python library designed to scan pickle files for malicious code before they are deserialized. A flaw in versions before 0.0.29 allows attackers to bypass this safety mechanism by embedding malicious code using lib2to3.pgen2.grammar.Grammar.loads in the pickle's reduce method. When an application uses picklescan to check a file but then deserializes it anyway, the malicious payload executes during pickle.load(), giving attackers remote code execution.

• CVE-2025-71360HIGH 8.1

  Picklescan, a security scanning tool designed to detect malicious Python pickle files, has a detection bypass vulnerability affecting versions before 0.0.29. Attackers can craft pickle files that use the idlelib.calltip.get_entity function within reduce methods to evade picklescan's defenses. When a victim loads these crafted pickle files, arbitrary remote commands execute on their system. This is a critical supply-chain risk because picklescan is often deployed as a safety layer in applications that process untrusted pickle data.

• CVE-2025-71361HIGH 8.1

  CVE-2025-71361 is a remote code execution vulnerability in picklescan, a library designed to detect malicious code in Python pickle files. Versions before 0.0.29 fail to catch a specific attack technique using idlelib.calltip.Calltip.fetch_tip calls. An attacker can craft a pickle file containing this hidden payload that executes arbitrary code when a victim loads it with pickle.load(), bypassing picklescan's safety checks entirely.

• CVE-2025-71362HIGH 8.1

  picklescan is a security tool designed to scan Python pickle files for potentially dangerous code before they are deserialized. A flaw in versions prior to 0.0.33 allows attackers to bypass this protection by embedding malicious code that exploits a specific numpy function call pattern. When a pickle file containing this exploit is opened, the embedded code executes with the privileges of the user running the application. This affects anyone relying on picklescan to safely handle pickle files from untrusted sources.

• CVE-2025-71363HIGH 8.1

  picklescan is a Python library designed to detect malicious code in pickle files before they're deserialized. A flaw in picklescan versions before 0.0.30 allows attackers to craft pickle files that evade this detection by using cProfile.run function calls. When a user deserializes one of these malicious files, arbitrary code executes on their system. This is a critical failure in a security-focused tool—the very library meant to prevent pickle deserialization attacks can be bypassed.

• CVE-2025-71364HIGH 8.1

  CVE-2025-71364 is a high-severity flaw in picklescan, a security tool designed to detect malicious pickle files before they're loaded in Python applications. Versions before 0.0.30 have a blind spot: they fail to recognize a specific built-in function from asyncio that attackers can embed in crafted pickle files. When an application uses vulnerable picklescan to validate what it believes is a safe pickle file, the malicious payload bypasses detection and executes arbitrary code on the system. The attack requires user interaction—someone or some process must load the pickle file—but once that happens, an attacker gains full code execution.

• CVE-2025-71365HIGH 8.1

  picklescan is a Python security tool designed to detect malicious pickle files—a serialization format that can execute arbitrary code when deserialized. This vulnerability allows attackers to craft pickle files that slip past picklescan's detection by using a specific code path involving numpy's f2py.crackfortran.myeval function. When a user or application loads one of these malicious files thinking it's safe, the embedded code runs with the privileges of the process, potentially compromising the system.

• CVE-2025-71366HIGH 8.1

  picklescan is a Python library designed to scan pickle files for malicious code before they're loaded. Version 0.0.27 and earlier have a critical blind spot: they fail to detect when attackers embed calls to torch.utils.bottleneck.__main__.run_cprofile inside pickle files. An attacker can craft a malicious pickle file that passes picklescan's safety checks, then execute arbitrary code when a victim loads the file. The vulnerability requires user interaction (a victim must load the file), but once they do, the attacker gains full code execution with the victim's privileges.

• CVE-2025-71367HIGH 8.1

  picklescan, a security tool designed to scan Python pickle files for malicious code, has a bypass vulnerability in versions before 0.0.34. The tool fails to recognize a specific Python operator function (_operator.attrgetter) when it appears in crafted pickle payloads. An attacker can exploit this gap by embedding this function in a pickle file's reduce method—the mechanism pickle uses to reconstruct Python objects. When a developer or application uses pickle.load() to deserialize such a file, the malicious code executes because picklescan never flagged it as dangerous. This is particularly concerning because picklescan is often used as a front-line defense against pickle deserialization attacks.

• CVE-2025-71368HIGH 8.1

  picklescan is a Python security tool designed to scan pickle files for malicious code before they are deserialized. Version 0.0.29 and earlier contain a detection gap: they fail to recognize the doctest.debug_script function as a dangerous payload. An attacker can craft a malicious pickle file that embeds a call to doctest.debug_script, which executes arbitrary commands when the pickle is loaded by a victim. Because picklescan doesn't flag this function, users relying on it for protection may unknowingly deserialize and execute hostile code.

• CVE-2025-71369HIGH 8.1

  picklescan is a security tool designed to inspect Python pickle files and detect malicious payloads before they are deserialized. A flaw in versions before 0.0.28 allows attackers to craft pickle files that evade picklescan's detection by leveraging a specific PyTorch utility (torch.utils.data.datapipes.utils.decoder.basichandlers) within reduce methods. When a user or system trusts picklescan's clearance and deserializes such a file, the embedded malicious code executes with full privileges, potentially compromising the affected system.

• CVE-2025-71370HIGH 8.1

  picklescan, a library designed to detect malicious content in Python pickle files before they're deserialized, has a detection bypass vulnerability. Attackers can craft pickle files that embed a specific PyTorch function (torch.jit.unsupported_tensor_ops.execWrapper) in a way that picklescan fails to recognize as dangerous. When these files are loaded with pickle.load(), arbitrary code executes. The vulnerability affects picklescan versions before 0.0.28 and represents a critical failure in a security tool meant to prevent exactly this type of attack.

• CVE-2025-71371HIGH 8.1

  picklescan is a Python library designed to scan pickle files for malicious code before they're deserialized. A vulnerability in versions before 0.0.29 allows attackers to craft specially-crafted pickle payloads that evade picklescan's detection by using code.InteractiveInterpreter.runcode in reduce methods. When a user loads such a malicious pickle file, arbitrary code executes despite the file passing picklescan validation. This creates a false sense of security for teams relying on picklescan to vet untrusted pickle data.

• CVE-2025-71372HIGH 8.1

  Picklescan is a security tool designed to detect malicious code hidden in Python pickle files before they're executed. A vulnerability in versions before 0.0.33 allows attackers to bypass this protection by using a specific Python gadget chain (numpy.f2py.crackfortran.getlincoef) that Picklescan fails to recognize. An attacker can create a malicious pickle file that looks safe to Picklescan but executes arbitrary code when loaded, potentially compromising systems that rely on Picklescan to validate untrusted pickle data—particularly in machine learning supply chains where serialized models are shared.

• CVE-2025-71373HIGH 8.1

  picklescan is a Python security library designed to scan pickle files for malicious code before they are deserialized. A flaw in versions before 0.0.33 allows attackers to craft pickle payloads that bypass picklescan's safety checks by using the operator.methodcaller function—a standard Python function that picklescan fails to recognize as dangerous. When an application loads such a malicious pickle file after passing it through picklescan, arbitrary code execution occurs, defeating the entire purpose of the validation step.

• CVE-2025-71374HIGH 8.1

  picklescan is a security tool designed to scan Python pickle files for dangerous code before they are deserialized. Prior to version 0.0.29, picklescan had a detection gap: it failed to identify when the built-in Python profile.Profile.run function was used within pickle reduce methods. An attacker can exploit this gap by crafting a malicious pickle file that uses this undetected function to execute arbitrary code when the file is deserialized, even after passing through picklescan's security checks.

• CVE-2025-71375HIGH 8.1

  CVE-2025-71375 is a detection bypass vulnerability in picklescan, a security tool designed to scan Python pickle files for malicious code. Versions before 0.0.34 fail to recognize the _operator.methodcaller function, which attackers can exploit to craft pickle payloads that pass safety checks but execute arbitrary code when unpickled. This turns a defensive tool into a false sense of security, making it particularly dangerous for organizations relying on picklescan to validate untrusted pickle data.

• CVE-2025-71376HIGH 8.1

  picklescan, a Python library designed to detect malicious pickle files before they're loaded, has a critical detection bypass in versions before 0.0.29. Attackers can craft pickle files that hide arbitrary code execution payloads using a specific Python class (idlelib.autocomplete.AutoComplete.fetch_completions) within pickle serialization reduce methods. When a victim loads such a file with picklescan 0.0.28 or earlier, the scanner fails to flag it as dangerous, allowing the embedded malicious code to execute. This is particularly dangerous because pickle files are often used for data persistence, model storage in machine learning workflows, and configuration management—areas where developers might trust scanning tools to catch threats.

• CVE-2025-71378HIGH 8.1

  picklescan is a security tool designed to detect malicious code hidden in Python pickle files before they're loaded. A vulnerability in picklescan versions before 0.0.30 allows attackers to hide malicious code using the cProfile.runctx function in ways the tool fails to recognize. When a user thinks they're safely loading a scanned pickle file, the malicious code executes anyway, potentially giving attackers full control of the system. The vulnerability requires user interaction—someone must actually load the pickle file—but once they do, the attacker can run arbitrary commands.

• CVE-2026-10750HIGH 8.1

  The Royal MCP WordPress plugin contains a critical authorization bypass flaw affecting versions before 1.4.26. After a user authenticates to WordPress, the plugin fails to verify that user actually has permission to use most of its tools. This means a low-level user—even one with minimal site access, like a Subscriber—can access private posts, see a complete list of all users and their roles, and create, modify, or delete content belonging to other users. The vulnerability only requires an attacker to have a valid WordPress login; no additional exploitation steps are needed.

• CVE-2026-10795HIGH 8.1

  UpdraftPlus, a popular WordPress backup and migration plugin, contains a critical authentication flaw that allows attackers to bypass security checks and impersonate site administrators. By exploiting weak signature verification and a predictable encryption key in the plugin's remote communication system, an attacker can craft fake commands that the plugin will execute with full admin privileges. This could enable uploading and activating malicious plugins, leading to complete site compromise.

• CVE-2026-10820HIGH 8.1

  A widely-used WordPress plugin for managing memberships and user access contains a critical authorization flaw. Any logged-in user can cancel subscription accounts belonging to other users by manipulating request parameters. The plugin fails to verify ownership before processing cancellation requests, creating an Insecure Direct Object Reference (IDOR) vulnerability. This allows attackers to disrupt revenue streams and deny service to legitimate paying subscribers without elevated privileges.

• CVE-2026-10863HIGH 8.1

  A vulnerability in MISP's correlations endpoint allowed authenticated users to manipulate how search results were ordered by injecting values into the order parameter. Rather than applying a server-defined sort, the application accepted user input that could be passed unsafely to the database layer. An attacker with valid credentials could exploit this to reorder results in ways the application designers didn't intend, potentially exposing information through creative query construction or gaining visibility into data the endpoint should have restricted.

• CVE-2026-10887HIGH 8.1

  A use-after-free flaw in Chrome's Chromoting remote desktop feature on macOS allows attackers to execute arbitrary code by sending specially crafted network traffic. The vulnerability exists in versions prior to 149.0.7827.53 and requires no user interaction—an attacker on the network can trigger the bug remotely, making this a critical threat to any Mac user running an affected Chrome version.

• CVE-2026-10930HIGH 8.1

  An out-of-bounds read vulnerability in ANGLE (the graphics translation layer used by Chrome on macOS) allows attackers to read sensitive memory from your system by tricking you into visiting a malicious website. The flaw affects Chrome versions before 149.0.7827.53 on Apple macOS. While the attacker cannot directly modify data or take control of your system through this specific vulnerability, they can extract confidential information—including passwords, encryption keys, or other sensitive data stored in memory—and cause Chrome to crash.

• CVE-2026-11011HIGH 8.1

  A flaw in Google Chrome's Password Manager allows an attacker who has already compromised the browser's renderer process to sidestep site isolation—a critical security boundary that prevents one website from accessing data belonging to another. By crafting a malicious HTML page, the attacker could potentially access sensitive information across different sites. This vulnerability affects Chrome versions before 149.0.7827.53 and requires the attacker to first gain control of the renderer process, which typically happens through a separate exploit or malicious website.

• CVE-2026-11015HIGH 8.1

  A memory reading flaw in Google Chrome's WebGPU component allows attackers to read data outside the intended memory boundaries when a user visits a specially crafted website. The vulnerability requires user interaction (visiting a malicious page) but does not require special privileges, and while the attacker cannot modify data or directly crash the browser, they can extract sensitive information from the process's memory—such as passwords, keys, or other confidential data stored there.

• CVE-2026-11111HIGH 8.1

  A memory reading vulnerability exists in Chrome's graphics engine (ANGLE) that allows attackers to access out-of-bounds data on a victim's system. An attacker could craft a malicious webpage that, when visited, leaks sensitive information from the browser's memory without modifying or corrupting system data. This affects Chrome versions prior to 149.0.7827.53. The vulnerability requires user interaction—a person must visit the malicious page—but once there, the attacker gains read access to protected memory regions.

• CVE-2026-11169HIGH 8.1

  Google Chrome versions before 149.0.7827.53 contain a flaw in how they process XML files that allows attackers to inject malicious scripts or HTML content into a webpage, even when normal security protections should prevent it. An attacker would need to trick a user into opening a specially crafted XML file, but once successful, the injected code can execute with the same privileges as the user, potentially stealing data or taking other harmful actions. The vulnerability affects Chrome on Windows, macOS, and Linux systems.

• CVE-2026-11170HIGH 8.1

  Google Chrome on Linux contains a vulnerability in its Chromoting feature (the remote desktop capability) that allows an attacker on the network to gain administrative privileges on your system without needing to interact with you. The vulnerability exists in Chrome versions before 149.0.7827.53. While the Chromium project rates this as medium severity, the actual impact—unauthenticated remote privilege escalation—warrants a CVSS score of 8.1 (HIGH), reflecting the seriousness for Linux desktop environments where Chromoting might be enabled.

• CVE-2026-11185HIGH 8.1

  A use-after-free flaw in the V8 JavaScript engine affects Google Chrome versions before 149.0.7827.53. The vulnerability requires an attacker to trick a user into installing a malicious Chrome extension, which can then execute arbitrary code within the browser's sandbox. While the Chromium project rated this as Medium severity, the CVSS score of 8.1 reflects the high potential impact on confidentiality and integrity. This is a memory safety issue that leverages social engineering to gain code execution capabilities.

• CVE-2026-11224HIGH 8.1

  A use-after-free vulnerability in Google Chrome's Chromoting remote desktop feature on Linux systems can allow an attacker to execute arbitrary code on a victim's machine through specially crafted network traffic. The attacker does not need any special privileges or user interaction beyond network access. This is a critical flaw in the remote desktop protocol handling that leaves systems open to full code execution compromise.

• CVE-2026-11231HIGH 8.1

  Google Chrome on macOS contains a flaw in its Safe Browsing feature that could allow an attacker to run malicious code on a user's computer. The vulnerability requires user interaction—specifically, the user must open or interact with a malicious file. While Chromium's security team classified the underlying issue as low severity, the CVSS score of 8.1 reflects the real-world impact: an attacker gaining code execution on the system. This affects Chrome versions prior to 149.0.7827.53 on macOS.

• CVE-2026-11311HIGH 8.1

  NGINX Gateway Fabric contains a configuration injection vulnerability that allows authenticated users with permission to create or modify certain Kubernetes Custom Resources to inject malicious NGINX directives. By crafting specially-formatted values in the serverTokens field (NginxProxy resource) or extraAuthArgs field (AuthenticationFilter resource), an attacker can insert arbitrary configuration that alters how NGINX processes requests. The vulnerability requires valid cluster credentials and appropriate RBAC permissions to exploit, making it a control-plane risk rather than a direct data-plane exposure.

• CVE-2026-11348HIGH 8.1

  HAVELSAN Inc.'s Liman MYS contains a flaw in how it validates cryptographic signatures, allowing an attacker to forge the origin of data. This means an attacker could spoof legitimate communications or commands, potentially impersonating trusted sources without detection. The vulnerability affects versions prior to Master.1107 and requires network access but not user interaction to exploit.

• CVE-2026-11416HIGH 8.1

  MoviePilot, a media download application, has a critical flaw in how it handles files downloaded from cloud storage services like AliPan, U115, and Rclone. When a file is downloaded, the application takes the filename provided by the cloud service and directly uses it to determine where to save the file locally. An attacker who compromises or manipulates the cloud storage metadata can craft a filename containing path traversal sequences (like ../) to trick MoviePilot into writing files outside the intended download directory. This could allow overwriting sensitive application files, configuration files, or plugins, potentially compromising the entire system.

• CVE-2026-11643HIGH 8.1

  A use-after-free vulnerability exists in Google Chrome's Proxy component that could allow attackers to execute arbitrary code on victim machines through specially crafted network traffic. The flaw affects Chrome versions prior to 149.0.7827.103 and has been rated as Critical by the Chromium security team. While no active exploitation has been confirmed in the wild, the vulnerability's remote nature and code execution potential make it a significant threat requiring prompt patching.

• CVE-2026-11689HIGH 8.1

  A vulnerability in Google Chrome versions before 149.0.7827.103 allows an attacker who has already compromised Chrome's renderer process to break through site isolation—Chrome's security boundary that keeps websites from accessing each other's data. An attacker would need to trick a user into visiting a malicious webpage after the renderer is already compromised, but if successful, they could read or modify sensitive information across different websites.

• CVE-2026-11693HIGH 8.1

  Google Chrome versions before 149.0.7827.103 contain a flaw in how plugins are handled that allows a remote attacker to break through Chrome's site isolation security boundary. Site isolation is Chrome's defense mechanism that keeps different websites in separate processes to prevent one compromised site from accessing data from another. An attacker who has already compromised the renderer process—the part of Chrome that executes web pages—can craft a malicious HTML page to bypass this isolation, potentially gaining unauthorized access to sensitive data from other open websites or sessions.

• CVE-2026-11794HIGH 8.1

  A vulnerability in the Advanced Form Integration plugin for WordPress allows unauthenticated users to create administrator accounts through form submissions. The plugin fails to validate or restrict the WordPress role assigned when users are auto-created from public form data. An attacker can exploit this if the site has configured a form field to map directly to user role assignment—a non-default setup that some integrations may enable. Success requires knowledge of the specific form configuration, but once exploited, grants full administrative control over the WordPress installation.

• CVE-2026-11800HIGH 8.1

  Keycloak has a JWT algorithm confusion vulnerability in its Authorization Grant flow that allows attackers with valid client credentials to forge authentication assertions and bypass signature verification. This flaw enables an attacker to create unauthorized access tokens and impersonate any federated user connected to the affected Identity Provider, resulting in unauthorized access and potential privilege escalation within systems that rely on Keycloak for authentication.

• CVE-2026-11816HIGH 8.1

  Keras, a widely-used machine learning library, contains a path traversal vulnerability in its archive extraction functions that can allow attackers to write files outside the intended extraction directory. The vulnerability affects Keras versions before 3.14.0 and stems from validation logic that checks paths against the wrong directory reference—the process's current working directory instead of where files are actually being extracted. In common environments like Docker containers and Jupyter notebooks where the working directory is set to the filesystem root, this check becomes ineffective. An attacker can craft a malicious archive that, when extracted by a vulnerable Keras application, overwrites critical files on the system or injects malicious code into machine learning pipelines.

• CVE-2026-11846HIGH 8.1

  CVE-2026-11846 is a file deletion flaw in IEI Integration Corp's iVEC-IEI Virtualization Edge Computer that lets authenticated users remotely delete arbitrary files or folders on affected systems. An attacker with valid credentials can weaponize this to destroy data, corrupt configurations, or crash services. The vulnerability carries a CVSS score of 8.1 (HIGH) because it requires authentication but enables substantial operational damage.

• CVE-2026-12012HIGH 8.1

  Google Chrome contains a use-after-free flaw in its network handling code that could allow attackers on a privileged network position to corrupt Chrome's memory and potentially execute code. The vulnerability affects Chrome versions before 149.0.7827.115 and is rated High severity. An attacker would need both network access and the ability to intercept or manipulate traffic, but would not need user interaction to trigger the flaw.

• CVE-2026-12083HIGH 8.1

  A flaw in the Admin and Site Enhancements (ASE) WordPress plugin allows attackers to restore demoted administrator accounts without any authentication. An attacker can exploit this to regain full administrative control of a WordPress site. This is a critical privilege escalation that bypasses the plugin's own access controls. The vulnerability affects versions before 8.8.4 of both the free ASE plugin and the pro version.

• CVE-2026-12246HIGH 8.1

  NSD, a popular authoritative DNS nameserver, contains a stack buffer overflow vulnerability triggered when processing specially crafted APL (Address Prefix List) resource records. An authenticated attacker can craft a malicious zone file with an APL record that declares a larger address length than is valid for its address family, causing up to 111 bytes of attacker-controlled data to overwrite the stack when the zone is written to disk. This vulnerability affects NSD version 4.14.0 and requires the attacker to have zone transfer or update privileges.

• CVE-2026-12290HIGH 8.1

  Mozilla has fixed a memory safety vulnerability in Firefox and Thunderbird that could allow attackers to compromise user confidentiality and data integrity. An attacker can exploit this flaw remotely over the network by tricking a user into visiting a malicious webpage or opening a specially crafted file. The vulnerability does not enable attackers to crash applications or cause denial of service, but it does create pathways to steal sensitive information or manipulate user data. Updates are available across Firefox, Firefox ESR (Extended Support Release), and Thunderbird versions.

• CVE-2026-12292HIGH 8.1

  A boundary condition flaw in Firefox and Thunderbird's Web Audio component allows attackers to corrupt memory through specially crafted content. The vulnerability requires user interaction—such as visiting a malicious webpage or opening a hostile document—but once triggered, it can lead to information disclosure or arbitrary code execution. Mozilla has released patches across all affected product lines.

• CVE-2026-12326HIGH 8.1

  Firefox and Thunderbird version 151 contain memory safety defects that could allow an attacker to run arbitrary code on an affected system. Mozilla patched these issues in version 152. While exploitation requires significant effort and specific conditions, the risk is serious because successful attacks could grant complete control over the affected application and potentially the underlying system.

• CVE-2026-12327HIGH 8.1

  Mozilla has patched multiple memory safety flaws affecting Firefox, Firefox ESR, Thunderbird, and Thunderbird ESR. These bugs can corrupt memory during program execution, and researchers believe they could potentially be exploited to execute arbitrary code on affected systems. The vulnerabilities have been fixed in Firefox 152, Firefox ESR 140.12, Thunderbird 152, and Thunderbird 140.12.

• CVE-2026-12328HIGH 8.1

  Multiple memory safety bugs have been identified in Firefox, Firefox ESR, Thunderbird, and Thunderbird ESR across several recent versions. These flaws involve improper memory handling that could potentially allow attackers to execute arbitrary code on affected systems. The issues stem from memory corruption vulnerabilities that were discovered during Mozilla's routine security review. All affected versions have received security updates to remediate these issues.

• CVE-2026-12378HIGH 8.1

  A WordPress plugin called Appointment Booking Calendar Plugin (also known as the Scheduling Plugin) contains a critical flaw in how it handles data. The plugin fails to properly validate user input before deserializing it in PHP, which is a dangerous operation. This means an attacker without needing to log in can send malicious data that gets converted into PHP objects. If the hosting WordPress site has certain vulnerable code libraries (gadget chains) available, an attacker can chain these objects together to execute arbitrary code directly on the server. This is a remote code execution vulnerability that can lead to complete server compromise.

• CVE-2026-12595HIGH 8.1

  LoginPress Pro, a WordPress authentication plugin, contains a critical flaw in its Discord login integration. When users sign in via Discord OAuth, the plugin fails to verify that the email address returned by Discord has been confirmed by the user. An attacker can register a Discord account with someone else's email address (without Discord verifying it) and use Discord's standard login flow to hijack that person's WordPress account. This works for any account, including administrator accounts, and requires no special access or social engineering—only knowledge of a target's email address.

• CVE-2026-12597HIGH 8.1

  LoginPress Pro, a popular WordPress authentication plugin, contains a flaw in its GitHub login integration that allows attackers to log into any user account—including admin accounts—without knowing their password. The vulnerability stems from the plugin accepting unverified email addresses from GitHub as proof of identity. An attacker can add someone else's email address to their GitHub profile (as an unverified email) and use that to trick the plugin into granting access to the corresponding WordPress account. While exploitation requires specific conditions around how GitHub orders email addresses in its response, the underlying design flaw is severe: the plugin never checks whether an email is actually verified before trusting it for account binding.

• CVE-2026-12598HIGH 8.1

  The LoginPress Pro WordPress plugin contains a critical flaw in its Spotify social login feature that allows attackers to hijack any WordPress account, including administrator accounts. The vulnerability stems from the plugin accepting an unverified email address from Spotify without confirming that the attacker actually owns that email or the target WordPress account. An attacker simply needs to create a Spotify account using someone else's email address and then use Spotify's login feature on the vulnerable WordPress site to gain full access to that person's account.

• CVE-2026-12740HIGH 8.1

  Plack::Middleware::OAuth versions up to 0.10 contain a critical flaw in how they handle OAuth 2.0 login flows. The middleware fails to implement the OAuth 2.0 state parameter, which is a security mechanism designed to prevent attackers from hijacking login sessions. An attacker can exploit this by completing an OAuth authorization with their own account and tricking a victim into using that authorization callback. The victim's session would then become logged in as the attacker, potentially granting the attacker permanent access to the victim's account if it becomes linked in the application.

• CVE-2026-12746HIGH 8.1

  Dancer2::Plugin::Auth::OAuth::Provider (Perl library) before version 0.23 fails to implement a critical security check during OAuth 2.0 login flows. The plugin doesn't generate or validate a 'state' parameter—a token that binds an authorization request to a specific user session. This omission allows attackers to hijack login sessions through cross-site request forgery (CSRF). An attacker can initiate an OAuth login with their own account, capture the resulting authorization code, and trick a victim into using it. The victim's session then incorrectly completes the login as the attacker, potentially granting the attacker persistent access to the victim's account if the application links OAuth identities to user profiles.

• CVE-2026-13020HIGH 8.1

  Esri's Portal for ArcGIS contains a flaw in how it handles forgotten password requests. An attacker can exploit this weakness to take over user accounts without authorization. The vulnerability affects Portal for ArcGIS version 12.1 and earlier on Windows, Linux, and Kubernetes deployments. Organizations running these versions should prioritize patching or implementing the recommended email server configuration to enable secure self-service password recovery.

• CVE-2026-13774HIGH 8.1

  A use-after-free memory vulnerability exists in Google Chrome's extension handling mechanism. An attacker can exploit this by tricking a user into installing a malicious Chrome extension, which could then execute arbitrary code with the privileges of the Chrome browser. The vulnerability affects Chrome versions before 150.0.7871.47 and is rated as high-severity by CVSS standards, though Google classifies the underlying issue as critical from a Chromium perspective.

• CVE-2026-13779HIGH 8.1

  A use-after-free memory vulnerability exists in Chrome's remote desktop (Chromoting) feature on ChromeOS. An attacker sending specially crafted network traffic could trigger this flaw to run arbitrary code on a victim's device. The vulnerability affects Chrome on ChromeOS versions prior to 150.0.7871.47 and carries Google's Critical severity rating.

• CVE-2026-13787HIGH 8.1

  A use-after-free vulnerability exists in Google Chrome's Chromoting feature (remote desktop functionality) on Windows systems. The flaw allows an attacker to send specially crafted network traffic that causes Chrome to use memory that has already been freed, potentially leading to arbitrary code execution. This is a remote attack that requires no user interaction beyond having Chrome running, though specific network conditions must align for exploitation to succeed.

• CVE-2026-13791HIGH 8.1

  CVE-2026-13791 is a code execution vulnerability in Google Chrome's download handling system that affects versions prior to 150.0.7871.47. The flaw stems from insufficient validation of user-supplied input when processing malicious Chrome extensions. An attacker must first convince a user to install a specially crafted extension, but once installed, the extension can execute arbitrary code with the privileges of the Chrome process. This represents a post-installation code execution risk rather than a browser compromise via web browsing alone.

• CVE-2026-13799HIGH 8.1

  A use-after-free defect in Google Chrome's QUIC protocol implementation allows attackers to trigger memory corruption by sending specially crafted network packets. An attacker can exploit this remotely without user interaction or special privileges. While the vulnerability requires specific network conditions to trigger (reflected in the CVSS complexity score), successful exploitation could enable arbitrary code execution on affected systems.

• CVE-2026-13806HIGH 8.1

  Google Chrome versions before 150.0.7871.47 contain a vulnerability in its Accessibility feature that allows an attacker to break out of the browser's site isolation sandbox. Site isolation is Chrome's defense mechanism that keeps different websites in separate processes so that a compromised website cannot steal data from other sites. This vulnerability requires two conditions: the attacker must first compromise the renderer process (the part of Chrome that runs website code), and the user must visit a malicious HTML page. If both occur, the attacker can bypass site isolation to access data from other open websites.

• CVE-2026-13819HIGH 8.1

  A memory-reading vulnerability exists in the ANGLE graphics library within Google Chrome on macOS versions prior to 150.0.7871.47. An attacker who has already compromised Chrome's renderer process can craft a malicious web page to read data from outside the intended memory boundaries, potentially exposing sensitive information. The vulnerability requires the attacker to have already gained control of the renderer process, which typically happens after successful exploitation of another Chrome vulnerability.

• CVE-2026-13864HIGH 8.1

  A flaw in Google Chrome's WebHID (Web Hardware Interface Device) policy enforcement allows attackers to escalate their privileges if they can trick a user into installing a malicious browser extension. While the attack requires social engineering—convincing someone to install the extension—the underlying technical weakness is significant because it bypasses Chrome's normally strict security boundaries around hardware access. Once installed, the extension gains the ability to interact with USB and other hardware devices in ways that shouldn't be possible, effectively elevating its capabilities beyond what the user intended to grant.

• CVE-2026-13974HIGH 8.1

  Google Chrome on macOS contains an integer overflow flaw in its Safe Browsing feature that allows an attacker to bypass navigation restrictions through a malicious file. The vulnerability requires user interaction—specifically, the user must open or download a malicious file—but once triggered, it can lead to integrity compromise and availability impact. This affects Chrome versions prior to 150.0.7871.47 on macOS systems.

• CVE-2026-14011HIGH 8.1

  Google Chrome versions prior to 150.0.7871.47 contain an out-of-bounds read vulnerability in the SurfaceCapture component. An attacker can exploit this flaw by crafting a malicious HTML page that, when visited by a user, triggers an out-of-bounds memory read. While the Chromium team classified this as Medium severity internally, the CVSS 3.1 score of 8.1 reflects the high practical risk: an attacker gains unauthorized access to sensitive memory contents without requiring special privileges, and the vulnerability impacts both confidentiality and availability.

• CVE-2026-14032HIGH 8.1

  A use-after-free memory vulnerability exists in the Bluetooth implementation of Google Chrome on macOS. An attacker could exploit this by convincing a user to install a malicious Chrome extension, which could then execute arbitrary code with the privileges of the browser. While the Chromium project classified this as low severity internally, the CVSS score reflects the potential for complete system compromise once code execution is achieved.

• CVE-2026-14090HIGH 8.1

  A vulnerability in Google Chrome's camera capture feature fails to properly validate untrusted input, allowing an attacker to craft a malicious HTML page that triggers an out-of-bounds memory read. An unsuspecting user who visits the compromised page could have sensitive data extracted from Chrome's memory. This affects Chrome on ChromeOS versions before 150.0.7871.47. While Google rates this internally as low severity, the CVSS score reflects the realistic risk: high confidence of exploitation and access to confidential information.

• CVE-2026-14111HIGH 8.1

  A use-after-free vulnerability exists in Google Chrome's WebProtect component that could allow an attacker to run malicious code on a user's system. The vulnerability requires social engineering—specifically convincing a user to install a malicious browser extension—but once that hurdle is cleared, an attacker can execute arbitrary code with the privileges of the Chrome process. This affects Chrome versions prior to 150.0.7871.47 across Windows, macOS, and Linux systems.

• CVE-2026-14122HIGH 8.1

  A flaw in Google Chrome's WebAppInstalls feature on Windows allows attackers to read and modify files on a victim's computer by tricking them into visiting a malicious website. The vulnerability requires user interaction—a victim must click or interact with a crafted webpage—but once triggered, it can expose sensitive data or alter files without additional restrictions. Google has patched this in Chrome 150.0.7871.47 and later.

• CVE-2026-14471HIGH 8.1

  Amazon's mcp-gateway-registry component contains a SQL injection vulnerability in its metrics-service retention policy management system. An authenticated attacker can inject malicious SQL commands through a table name parameter, potentially gaining unauthorized access to sensitive data or modifying database contents. The vulnerability affects versions before 1.0.13 and requires valid credentials to exploit.

• CVE-2026-22555HIGH 8.1

  Gitea, a self-hosted Git service, contains an authorization bypass flaw affecting versions before 1.26.0. Authenticated users can fork a repository into an organization they do not have explicit permission to create repositories within, circumventing a critical access control check. This bypass allows attackers to expose organization secrets that would normally be protected. The vulnerability requires an existing user account but poses significant risk to organizations relying on Gitea for internal code hosting and secret management.

• CVE-2026-22659HIGH 8.1

  FlaskBB versions through 2.2.0 contain a critical authorization flaw that allows authenticated forum moderators to manipulate topics they shouldn't have access to. By crafting specially formatted batch requests that mix a topic from a forum they do control with topics from forums they don't, attackers can bypass permission checks and lock, unlock, delete, or hide discussions across the entire forum. The vulnerability requires valid moderator credentials but no further user interaction, making it a practical risk in multi-forum deployments.

• CVE-2026-24065HIGH 8.1

  Waves Central for macOS contains a vulnerability that allows a local attacker to gain root-level access through a race condition in how the application validates connections. The vulnerable software trusts connections based on process IDs, which the operating system can reuse for different applications. An attacker can exploit the timing gap between when a connection is requested and when the validation occurs, tricking the privileged helper service into executing commands with administrator rights. This affects versions 13.0.9 through 16.5.5, and the issue is resolved in version 16.6.2.

• CVE-2026-2467HIGH 8.1

  A heap-based buffer overflow vulnerability exists in RTI Connext Professional's core libraries that allows authenticated users to overflow variables and tags in memory. An attacker with valid credentials can trigger this flaw to corrupt data or crash the application, but cannot directly read sensitive information. The vulnerability affects multiple versions of Connext Professional spanning several major releases.

• CVE-2026-24724HIGH 8.1

  CVE-2026-24724 is an authorization bypass vulnerability affecting QNAP File Station 6. An attacker with valid user credentials can exploit improper access control checks to gain unauthorized access to resources or functionality they should not be able to reach. The vulnerability requires an existing user account but does not require user interaction or special network conditions, making it a practical concern for environments where user account compromise is a realistic threat.

• CVE-2026-26239HIGH 8.1

  A buffer overflow flaw in QNAP File Station 5 allows authenticated users to corrupt memory or crash the application. While the vulnerability requires an attacker to first obtain valid user credentials, the impact—potential system compromise and denial of service—warrants prompt patching. QNAP has released a fix in version 5.5.6.5208 and later.

• CVE-2026-2674HIGH 8.1

  RTI Connext Professional contains an out-of-bounds write vulnerability affecting three key components: the Queueing Service, Core Libraries, and Persistence Service. An authenticated attacker can send a crafted message over the network to trigger a buffer overflow, potentially corrupting memory and causing a denial of service or allowing code execution. The vulnerability affects multiple version branches and requires network access plus valid credentials to exploit.

• CVE-2026-27333HIGH 8.1

  Paid Videochat Turnkey Site versions 7.3.23 and earlier contain a critical weakness that allows attackers to execute arbitrary code without needing login credentials. The vulnerability exists in how the application handles incoming data serialization—specifically, it accepts and processes untrusted data without proper validation. An attacker on the network can craft a malicious request to trigger code execution, potentially compromising the entire system.

• CVE-2026-27412HIGH 8.1

  Pearl - Corporate Business versions 3.4.10 and earlier contain a vulnerability that allows unauthenticated attackers to read arbitrary files from affected servers without requiring valid login credentials. By exploiting this flaw, a remote attacker can potentially expose sensitive configuration files, database credentials, source code, and other confidential information stored on the server. The vulnerability requires specific conditions to be met but does not require user interaction or authentication, making it a significant risk for organizations running vulnerable versions.

• CVE-2026-28699HIGH 8.1

  Gitea, a self-hosted Git service, has a critical flaw in how it enforces API permissions for OAuth2 applications. When someone logs in using HTTP Basic authentication (username and password), the system fails to respect the restricted access scopes that should apply to OAuth2 tokens. This means an attacker with a compromised user account or valid credentials could use HTTP Basic auth to perform actions that an OAuth2 application was explicitly forbidden from doing, such as modifying repositories or accessing sensitive information.

• CVE-2026-28744HIGH 8.1

  Gitea, a self-hosted Git platform, contains a flaw in how it validates API access tokens when developers use Git's smart HTTP protocol. An authenticated user with a token intended for limited access (scoped tokens) can bypass those restrictions and perform actions they shouldn't be allowed to do—such as reading or modifying repositories they lack permission for. This affects Gitea versions 1.26.1 and earlier. The vulnerability requires an attacker to already have valid credentials, but once authenticated, the scope bypass is straightforward to exploit.

• CVE-2026-30799HIGH 8.1

  RTI Connext Professional's security plugin layer is missing proper authentication checks on critical functions, allowing an authenticated user to impersonate other identities within the system. While this requires an attacker to already have legitimate access credentials, the impact is severe: unauthorized changes to system configuration or data could occur without detection. The vulnerability spans multiple product versions from 5.3.0 through 7.7.0.