2026 · Medium

Medium-severity vulnerabilities disclosed in 2026

Medium-rated CVEs published in 2026, with SEC.co remediation and prioritization guidance.

4010 published vulnerabilities · page 31 of 41

• CVE-2026-8617MEDIUM 5.3

  The SearchPlus WordPress plugin contains a flaw that allows anyone on the internet, without authentication, to modify or delete critical configuration data. Specifically, attackers can overwrite or erase the plugin's stored account tokens and account names by sending specially crafted requests. The vulnerability exists because the plugin fails to verify that the person making the request is actually authorized (missing capability checks) and doesn't use security tokens (nonces) to prevent cross-site forgery attacks. This affects all versions up to and including 1.7.1.

• CVE-2026-8690MEDIUM 5.3

  The RentMy Real-Time Rental Management Plugin for WordPress fails to verify user permissions before allowing changes to rental event data and location settings. This means anyone on the internet—without logging in—can read, modify, or delete rental events and overwrite the location ID stored in WordPress. The vulnerability affects all versions up to 4.0.4.1.

• CVE-2026-8694MEDIUM 5.3

  Devolutions PowerShell Universal versions up to 2026.1.7 contain an access control flaw that allows anyone on the network to read the OpenAPI specification files for REST endpoints you've created. These specification files can reveal sensitive details about your API structure, parameters, and authentication methods—information that normally should only be available to authenticated users. An attacker doesn't need valid credentials to exploit this; they simply request the specification and receive it.

• CVE-2026-8839MEDIUM 5.3

  MapPress Maps for WordPress, a popular mapping plugin, contains a critical authorization flaw affecting all versions through 2.96.6. The plugin's REST API endpoints fail to verify whether the person making a request actually owns the map they're trying to access. This means unauthenticated attackers can read any map's sensitive details—locations, coordinates, addresses, and descriptions—simply by guessing map IDs, while legitimate WordPress users with contributor-level access or higher can modify, delete, or duplicate maps they don't own.

• CVE-2026-9016MEDIUM 5.3

  A WordPress plugin called Debug Log Manager allows website visitors—including those not logged in—to write fake error messages directly into the site's debug log. The plugin publishes a security token publicly in every page's HTML code, defeating its own authorization checks. An attacker can exploit this to flood the log with fabricated entries, making it harder for administrators to spot real problems and potentially covering up malicious activity. This only affects sites that have the plugin's JavaScript error logging feature enabled.

• CVE-2026-9021MEDIUM 5.3

  The Easy Invoice WordPress plugin has a security flaw in versions 2.1.19 and earlier that lets anyone on the internet—without needing an account or credentials—accept or decline quotes and potentially convert them into invoices. The vulnerability exists because the plugin uses WordPress's no-privilege AJAX hooks (allowing unauthenticated access) paired with a basic nonce verification, but relies on an optional, disabled-by-default setting to actually check if someone owns the quote. An attacker can harvest the publicly visible nonce from any published quote page, then submit it to trigger quote acceptance/decline actions, potentially auto-generating and emailing invoices without authorization.

• CVE-2026-9027MEDIUM 5.3

  The CorvusPay WooCommerce Payment Gateway plugin contains a critical flaw in how it handles payment confirmations. When a customer completes a payment, the plugin is supposed to verify that the confirmation is genuinely from CorvusPay by checking a cryptographic signature. However, the plugin checks the signature but then ignores the result—it logs whether the check passed or failed, but proceeds to mark the order as paid regardless. This means an attacker can forge a fake payment confirmation and trick the plugin into marking any order as fully paid, allowing them to obtain merchandise or services without actually paying. Since WooCommerce order IDs are sequential numbers, attackers can systematically target orders without needing to know specific details beforehand.

• CVE-2026-9028MEDIUM 5.3

  The CorvusPay WooCommerce Payment Gateway plugin contains a flaw that allows anyone on the internet—with no account or credentials—to cancel orders placed through the CorvusPay payment method. An attacker simply needs to guess or iterate through order numbers and send a cancel request to a specific REST endpoint. This affects all versions of the plugin up to and including version 2.7.4.

• CVE-2026-9091MEDIUM 5.3

  Casdoor is an open-source identity and access management platform. A logic flaw in its social login binding feature allows attackers to bypass multi-factor authentication (MFA) requirements. When users authenticate through the social login binding flow, the application fails to check whether MFA is enabled, granting them access without completing the second authentication factor. This affects Casdoor versions 2.362.0 and earlier.

• CVE-2026-9172MEDIUM 5.3

  The Devs Accounting plugin for WordPress contains a critical flaw that allows anyone on the internet to delete accounting records without logging in. A REST API endpoint meant to delete account data lacks proper access controls, making it publicly accessible. An attacker can craft a simple web request targeting any account ID to permanently remove (soft-delete) accounting records from the WordPress database. This affects all installations running version 1.2.0 and earlier.

• CVE-2026-9175MEDIUM 5.3

  A WordPress plugin called Devs Accounting fails to properly verify user identity when serving financial data through its REST API. Anyone on the internet can request sensitive account information—like account names, bank details, and opening balances—without logging in or providing credentials. An attacker simply needs to guess or enumerate account ID numbers to retrieve this private financial data. The vulnerability affects all versions of the plugin up to and including version 1.2.0.

• CVE-2026-9180MEDIUM 5.3

  The MotoPress Appointment Booking plugin for WordPress contains a flaw that allows anyone on the internet to modify customer details in unconfirmed booking records without any authentication. An attacker can change the name, email, phone number, and internal customer ID associated with a booking that hasn't been confirmed yet. The vulnerability exists because the plugin's booking API endpoint accepts requests from anyone and doesn't verify that the person making the request actually owns the booking they're trying to modify. Attackers can discover target bookings by querying a publicly accessible list of appointments.

• CVE-2026-9187MEDIUM 5.3

  An unauthenticated attacker can permanently delete any post, page, or other content on a WordPress site running the Abandoned Contact Form 7 plugin up to version 2.2. The plugin fails to verify that requests come from authorized users and fails to validate that deletion requests are legitimate. This allows an attacker to send a simple request to the site's admin interface and destroy content without needing any credentials or password.

• CVE-2026-9188MEDIUM 5.3

  The Wappointment plugin for WordPress allows unauthenticated attackers to cancel or reschedule other users' appointments. The plugin generates authorization keys using a weak, predictable formula based on publicly observable or easily guessable information—a sequential customer ID, the appointment time, and staff ID—all hashed together without a random component. An attacker can recreate these keys and manipulate appointments belonging to other users if cancellation or rescheduling features are enabled on the site. This is a straightforward authorization bypass affecting all versions up to 2.7.6.

• CVE-2026-9189MEDIUM 5.3

  The Contact Form 7 – PayPal & Stripe Add-on WordPress plugin contains a payment validation flaw that allows attackers to mark high-value orders as completed without paying the correct amount. An attacker can make a small legitimate PayPal payment, then submit a forged payment notification (IPN) that references a different, expensive order. Because the plugin fails to verify that the payment amount and recipient email match the target order, the attacker's notification is accepted and the high-value order is incorrectly marked as paid. This affects all versions up to and including 2.4.9.

• CVE-2026-9204MEDIUM 5.3

  GitLab has fixed a vulnerability that lets authenticated users on versions 18.10 (before 18.10.8), 18.11 (before 18.11.5), and 19.0 (before 19.0.2) read files directly from the Gitaly server and reach internal network resources during repository imports. The issue stems from incomplete validation of secondary URLs in the import process. An attacker must already have valid GitLab credentials to exploit this flaw.

• CVE-2026-9242MEDIUM 5.3

  The RegistrationMagic plugin for WordPress contains a critical flaw in how it handles PayPal payment confirmations. An unauthenticated attacker can forge a fake PayPal notification to trick the plugin into associating a payment record with any WordPress user account—including admin accounts. By combining this forged notification with a legitimate security hash from a real payment, the attacker can then log in as that target user without knowing their password. The vulnerability affects all versions up to 6.0.8.6.

• CVE-2026-9590MEDIUM 5.3

  Devolutions Server versions up to and including 2026.1.19 contain an access control weakness that allows authenticated users with permission to edit entries to modify asset information beyond their intended scope. An attacker with entry edit privileges can bypass the permission validation checks and alter assets they shouldn't be able to access, potentially compromising the integrity of credential and asset data within the server.

• CVE-2026-9595MEDIUM 5.3

  webpack-dev-server's Hot Module Replacement (HMR) feature can be inadvertently exposed to a user-configured proxy when the proxy context is set broadly (such as /). If WebSocket forwarding is enabled on that proxy, the dev server mistakenly routes its internal HMR WebSocket through the proxy to a backend server. This causes sensitive data—browser cookies and the Origin header—to leak to that backend, circumvents the dev server's built-in Host/Origin protections, and corrupts the HMR socket since both HMR and the proxy write to the same connection. The flaw affects webpack-dev-server versions before 5.2.5.

• CVE-2026-9612MEDIUM 5.3

  The WhatsOrder – Instant Checkout for WooCommerce plugin contains a flaw that allows anyone on the internet to download customer invoices without logging in. The plugin saves invoice files to a web-accessible folder without proper access controls, and because invoice file names are predictable (based on sequential order IDs), attackers can systematically retrieve invoices for any customer. Each invoice contains sensitive personal information including names, email addresses, phone numbers, billing addresses, purchased items, prices, and order totals.

• CVE-2026-9641MEDIUM 5.3

  Crypt::PBKDF2, a Perl cryptographic library, uses cryptographic settings that are too weak by modern standards in versions before 0.261630. Specifically, the library defaults to HMAC-SHA1 (an older algorithm suitable only for legacy compatibility) and performs only 1,000 iterations of the key derivation process. Modern best practices recommend 220,000 to 1,400,000 iterations depending on the algorithm chosen. This gap between defaults and best practices weakens password protection for applications that rely on these defaults without customization.

• CVE-2026-9692MEDIUM 5.3

  Mojolicious::Sessions::Storable, a Perl session management module, uses a weak method to generate session identifiers through version 0.05. The session IDs are created by hashing together predictable data sources: the system's built-in random number generator (which is not cryptographically secure), the current timestamp, the memory address of a temporary data structure, and the process ID. An attacker with knowledge of these values or patterns could predict or forge valid session IDs, potentially gaining unauthorized access to user sessions without needing the correct credentials.

• CVE-2026-9794MEDIUM 5.3

  Keycloak contains an information disclosure vulnerability in its SAML ECP (Enhanced Client or Proxy) endpoint. An unauthenticated attacker can send specially crafted SOAP requests with different client IDs to the endpoint and observe the error messages returned. By analyzing these responses, an attacker can infer whether a given client uses SAML or another protocol. While this doesn't grant direct access to sensitive data or systems, it reveals organizational configuration details that could inform further reconnaissance or targeted attacks.

• CVE-2026-9803MEDIUM 5.3

  Keycloak's client registration endpoint contains a flaw that allows unauthenticated attackers to crash the service by sending malformed authentication headers. When an attacker sends a specially crafted POST request with a broken 'Authorization: Bearer' header to the client registration endpoint, the server throws an exception and returns an error, effectively taking the service offline temporarily. No data is stolen or modified—this is purely a denial of service issue.

• CVE-2026-9985MEDIUM 5.3

  A flaw in Google Chrome and ChromeOS allows an attacker who has already compromised the browser's renderer process to read sensitive data from the browser's memory by tricking a user into viewing a malicious webpage. The vulnerability stems from insufficient validation of media-related input. While this requires an initial renderer compromise, it can expose information that should have remained private within the browser process.

• CVE-2026-41984MEDIUM 5.2

  CVE-2026-41984 is a use-after-free (UAF) vulnerability discovered in a package management module. Use-after-free flaws occur when software attempts to access memory that has already been freed, potentially allowing an attacker to corrupt data or disrupt service. This particular issue requires high-level privileges to exploit and is unlikely to be triggered accidentally, but successful exploitation could compromise the integrity of the affected service.

• CVE-2026-49859MEDIUM 5.2

  Deno, a modern JavaScript and TypeScript runtime, contains a network access control bypass in versions before 2.8.1. When a script uses fetch() to make network requests, Deno's security model allows administrators to block connections to specific IP addresses or networks using the --deny-net flag. However, the vulnerability exists because Deno only checked the hostname against the deny list but failed to verify the actual IP addresses that hostname resolved to. An attacker could craft a malicious domain name that appears to pass the hostname restrictions yet resolves to a blocked IP address, allowing unauthorized network access. This was patched in version 2.8.1.

• CVE-2026-49860MEDIUM 5.2

  Deno versions before 2.8.1 contain a network access control bypass vulnerability in WebSocket connections. When a script attempts to open a WebSocket, Deno validates the destination hostname against deny-net security rules, but fails to re-validate the IP address that hostname resolves to. An attacker can craft a domain name that passes the hostname check but resolves to a blocked IP address, allowing network communication to restricted destinations. This affects local scripts with network privileges, potentially allowing unauthorized outbound connections despite active network restrictions.

• CVE-2026-49983MEDIUM 5.2

  Deno is a modern JavaScript/TypeScript runtime that includes permission controls to restrict what programs can access. One of these controls is the env permission, which blocks access to environment variables. You can use --deny-env to prevent this entirely, or --allow-env=FOO,BAR to restrict access to specific variables. However, in versions before 2.8.1, a built-in function called process.loadEnvFile() bypasses this protection. This function loads environment variables from a .env file, but it only checks whether the program can read the file—it ignores whether env access is allowed. This means an attacker who can control or create a .env file on the system, combined with read access (--allow-read), can inject environment variables into a sandboxed program that was supposed to have no env access. The vulnerability is patched in version 2.8.1.

• CVE-2026-11276MEDIUM 5.1

  Google Chrome versions before 149.0.7827.53 contain a flaw in how the Cast feature (which enables screen mirroring and media streaming to nearby devices) processes network traffic. An attacker physically present on the same local network can send specially crafted traffic to bypass access controls that would normally prevent unauthorized casting operations. This is a local network attack that doesn't require user interaction but is limited in scope—it cannot crash systems or execute arbitrary code, only manipulate casting permissions.

• CVE-2026-41985MEDIUM 5.1

  CVE-2026-41985 is a medium-severity memory safety defect in a package management module that can be exploited to disrupt service availability and data integrity. The vulnerability requires local system access, elevated user privileges, and user interaction to trigger, which constrains its real-world attack surface but does not eliminate its risk in insider threat or multi-stage compromise scenarios.

• CVE-2026-42326MEDIUM 5.1

  ImageMagick, a widely-used open-source tool for image processing, contains a flaw that allows a specially crafted image file to trigger an out-of-bounds memory read when the application writes IPTC metadata. An attacker who provides a malicious image could cause the software to read one byte of memory it shouldn't access, potentially leaking sensitive information or causing the application to crash. This is a local issue—the attacker must be able to supply the image file to a system running vulnerable ImageMagick.

• CVE-2026-45624MEDIUM 5.1

  ImageMagick, a widely used image editing library, contains an out-of-bounds memory read vulnerability in its polynomial distortion feature. When processing specially crafted image transformation arguments, the software reads 24 bytes of memory beyond the intended buffer boundary. This can expose sensitive data from the application's memory space. The vulnerability affects versions prior to 6.9.13-47 (legacy branch) and 7.1.2-22 (current branch) and has been patched in those releases.

• CVE-2026-45682MEDIUM 5.1

  OpenTelemetry's eBPF Instrumentation agent for Java contains a memory leak in its TLS connection state tracking. When Java applications handle repeated connection churn (connections opening and closing), the instrumentation fails to properly clean up its internal tracking queue, causing heap memory to grow indefinitely until the application runs out of memory and crashes. This affects long-running production JVMs where connection pools are regularly recycled. The issue is resolved in version 0.9.0.

• CVE-2026-55443MEDIUM 5.1

  LangChain versions prior to 1.3.9 contain a path-traversal vulnerability that allows unauthorized file access. Several components that load or search files do not properly restrict access to a configured directory boundary. An attacker who can influence file paths, search patterns, or LLM inputs could read files outside the intended scope—for instance, by using glob patterns, symbolic links, or prefix-matching tricks to escape a restricted directory and access sensitive files elsewhere on the system.

• CVE-2026-57965MEDIUM 5.1

  CVE-2026-57965 is a medium-severity vulnerability in spice-vdagent, a guest-side agent daemon used in virtualized environments to provide features like clipboard sharing and USB redirection. An attacker who controls or compromises the SPICE (Simple Protocol for Independent Computing Environments) host can craft a malicious network message that causes an integer overflow, leading to a heap buffer overflow in the vdagent daemon. This crash results in denial of service to the virtual machine. The vulnerability requires the host to be untrusted or already compromised, limiting exposure in typical well-managed hypervisor environments, but it represents a privilege escalation vector if host compromise occurs.

• CVE-2024-56141MEDIUM 5.0

  Minosoft, an open-source Minecraft Java Edition client, contains a cryptographic implementation flaw in its AES encryption routine. The application incorrectly uses the encryption key itself as the initialization vector (IV) instead of generating a random one. This design weakness allows attackers with network access and authenticated status to perform chosen-plaintext and chosen-ciphertext attacks, potentially recovering the secret encryption key. The vulnerability affects all Minosoft versions that support Minecraft protocol 1.7 and later. No patch has been released, and no workarounds currently exist.

• CVE-2025-60466MEDIUM 5.0

  GPAC MP4Box versions before 26.02.0 contain a memory safety flaw where freed memory can be accessed during packet filtering operations. An attacker who supplies a specially crafted media file can trigger a crash or service interruption. The vulnerability requires local access and user interaction (opening the file), limiting its direct remote exploitation potential but posing a risk in automated or batch processing environments.

• CVE-2025-60477MEDIUM 5.0

  CVE-2025-60477 is a crash vulnerability in GPAC's MP4Box multimedia processing tool. A specially crafted file can trigger a program crash when processed by a local or authenticated user, disrupting media encoding and processing workflows. The vulnerability does not leak data or enable privilege escalation, but it can be weaponized to interrupt legitimate operations or degrade service availability.

• CVE-2026-10010MEDIUM 5.0

  Google Chrome on Android versions prior to 148.0.7778.216 contain a vulnerability in input handling that allows an attacker who has already compromised Chrome's renderer process to bypass site isolation protections through a specially crafted HTML page. Site isolation is a critical Chrome security boundary designed to keep sensitive data from different websites separate in memory. This flaw undermines that protection, though it requires the attacker to have already gained code execution within the browser engine itself.

• CVE-2026-10275MEDIUM 5.0

  A buffer overflow vulnerability exists in OpenSC versions up to 0.26.1 within the pkcs11-tool component's key generation functionality. The flaw allows an attacker to overflow a buffer during certificate writing operations, potentially enabling remote code execution or data corruption. Exploitation requires user interaction and specific conditions, making it moderately difficult to weaponize, though a proof-of-concept has already been disclosed.

• CVE-2026-10533MEDIUM 5.0

  A vulnerability in OpenShift Container Platform allows non-privileged users to circumvent resource quota enforcement by creating pods with a never-restart policy. These pods and their associated Kubernetes events are not counted against quota limits, enabling an attacker to flood the cluster's event database (etcd) with activity. The resulting accumulation degrades API server performance across the entire cluster, affecting all users and workloads.

• CVE-2026-11281MEDIUM 5.0

  Google Chrome on Windows contains an integer overflow vulnerability in its Chromoting remote desktop component that could allow a local attacker with user-level privileges to read sensitive information from the browser's memory. The attack requires user interaction and relies on sending a specially crafted Event Tracing for Windows (ETW) event. This is a local-only attack requiring existing system access, not a remote exploitation vector.

• CVE-2026-11290MEDIUM 5.0

  An integer overflow vulnerability exists in the WebView component of Google Chrome on Android devices running versions prior to 149.0.7827.53. A local attacker with limited privileges can exploit this flaw by tricking a user into opening a specially crafted file, leading to a denial of service that crashes the browser or WebView. This is a local attack that requires user interaction and does not compromise confidentiality or integrity.

• CVE-2026-11455MEDIUM 5.0

  MetaGPT versions up to 0.8.2 contain a command injection vulnerability in the common utility module. An authenticated attacker can manipulate the mermaid.path argument to inject arbitrary system commands, potentially leading to unauthorized code execution. The flaw requires significant technical knowledge to exploit and has become public, increasing risk posture for organizations running affected versions.

• CVE-2026-11493MEDIUM 5.0

  Tenda AC15 routers running firmware version 15.03.05.19 contain a vulnerability in how they configure Samba file-sharing settings. An attacker with access to the local network can manipulate the Samba configuration file to weaken password requirements, making it easier to gain unauthorized access to shared files and network resources. While a public exploit exists, successful exploitation requires technical knowledge and specific network conditions.

• CVE-2026-11500MEDIUM 5.0

  Weaviate versions up to 1.37.7 contain an authorization bypass vulnerability in the static API key authentication handler. An authenticated attacker can manipulate the StaticApiKey parameter to bypass access controls and gain unauthorized access to protected resources. The vulnerability requires a valid user account and significant technical knowledge to exploit, but public exploit code exists. Upgrading to version 1.38.0-rc.0 resolves the issue.

• CVE-2026-11505MEDIUM 5.0

  GL.iNet routers across multiple models (A1300, AX1800, AXT1800, MT2500, MT3000, MT6000, X3000, XE3000) running firmware version 4.8.x contain a flaw in the glnassys component that exposes a hard-coded cryptographic key. An authenticated attacker with network access can exploit this to gain unauthorized cryptographic capabilities. The vulnerability requires significant technical skill and specific conditions to exploit, placing it in the medium-risk category. A firmware upgrade to version 4.9.0 resolves the issue.

• CVE-2026-11787MEDIUM 5.0

  A vulnerability in Red Hat's 389 Directory Server allows a memory reading flaw when processing LDAP search filters. The issue occurs when the server parses certain filter strings, causing it to read data from memory locations it shouldn't access. This could potentially be exploited by an authenticated user to leak small amounts of sensitive information or disrupt normal filter processing. The vulnerability requires authentication and specific conditions to exploit, making it a moderate-risk issue that warrants patching but not immediate panic.

• CVE-2026-11791MEDIUM 5.0

  A memory safety defect in 389 Directory Server can crash the service when an administrator reloads the schema while the server is handling active LDAP queries. The vulnerability stems from improper cleanup of attribute syntax data structures during schema reload, allowing worker threads to access memory that has already been freed. This condition results in a denial of service but does not enable data theft or modification.

• CVE-2026-11850MEDIUM 5.0

  MIT krb5 contains an integer underflow bug in how it processes LDAP-backed Kerberos principal data. When the LDAP KDB plugin reads a malformed krbExtraData attribute with insufficient length, a mathematical underflow occurs: subtracting 2 from a value smaller than 2 causes an unsigned integer to wrap around to a very large number (up to 65,535). The code then allocates memory based on this wrapped value and attempts to copy data from a tiny buffer into it, reading far beyond the buffer's actual contents. This can cause sensitive memory disclosure or service disruption on systems running a KDC or kadmind daemon that use LDAP for principal storage.

• CVE-2026-12771MEDIUM 5.0

  BerriAI's litellm, a language model proxy library, contains an authorization flaw in its M2M (machine-to-machine) JWT authentication handler. An authenticated attacker can manipulate requests to bypass proper authorization checks, potentially gaining unauthorized access to protected functionality. This requires existing credentials and significant technical knowledge to exploit, though proof-of-concept code is publicly available.

• CVE-2026-13484MEDIUM 5.0

  MLflow, a popular open-source platform for managing machine learning workflows, contains an authorization flaw in its experiment-scoped label schema API. An authenticated user with low privileges can manipulate this API endpoint to perform actions they should not be allowed to perform—specifically, reading, modifying, or deleting label schemas—without proper permission checks. The vulnerability requires an attacker to already have valid login credentials and involves moderately complex attack conditions, making it a practical but not trivial risk.

• CVE-2026-13507MEDIUM 5.0

  A vulnerability exists in volcengine OpenViking versions up to 0.3.21 that allows authenticated users to bypass data integrity checks when processing primary-key labels in the local vector database. An attacker with valid credentials can manipulate ID arguments to the str_to_uint64 function, causing the system to accept data without proper verification. While the vulnerability requires authentication and is technically complex to exploit, successful exploitation could compromise the confidentiality, integrity, and availability of indexed vector data.

• CVE-2026-13513MEDIUM 5.0

  MyScaleDB versions up to 1.8.0 contain a vulnerability in how they verify the authenticity of cached segment identifiers. An authenticated attacker with network access could manipulate this cache mechanism to bypass data integrity checks, potentially leading to unauthorized information disclosure or modification. The attack is complex to execute, but proof-of-concept code has been publicly released, increasing exploitation risk.

• CVE-2026-13534MEDIUM 5.0

  CherryHQ's cherry-studio application versions up to 1.9.7 contain an authorization bypass vulnerability in its CherryIN Preload API memory service. An authenticated attacker with local or remote access can manipulate a state parameter to bypass authorization controls and access unauthorized data or perform restricted actions. The vulnerability requires high technical complexity to exploit and is rated CVSS 5.0 (Medium). A public exploit exists, elevating practical risk for deployed instances.

• CVE-2026-13591MEDIUM 5.0

  DeepMyst Mysti version 0.4.0 contains a flaw in how it validates user permissions when tracking conversations. An authenticated attacker can manipulate how the system classifies conversation channels to bypass authorization controls, potentially gaining access to or modifying sensitive conversation data. The vulnerability requires an active user account and deliberate manipulation of request parameters, making it a targeted risk rather than a trivial one.

• CVE-2026-14340MEDIUM 5.0

  GitHub Enterprise Server had a flaw in how it validated permissions for tokens used by GitHub Apps. A user-to-server token tied to a GitHub App could be abused to create issues, comments, and vulnerability reports on public repositories even if the token was not supposed to have access to those repositories. An attacker who stole such a token could post content as the legitimate user, making it appear the user performed those actions. GitHub has patched this across all supported versions.

• CVE-2026-27881MEDIUM 5.0

  Coolify, an open-source platform for managing servers and applications, contains an authorization flaw that allows any authenticated API user to view deployment information belonging to other teams. An attacker with valid API credentials can retrieve sensitive deployment details—such as configuration, status, and metadata—for deployments they should not have access to by simply guessing or enumerating valid deployment identifiers. The vulnerability exists in versions prior to 4.0.0-beta.464 and is resolved in that release.

• CVE-2026-27883MEDIUM 5.0

  Coolify is a deployment and infrastructure management platform, and versions before 4.0.0-beta.464 contain an authorization bypass in the deployment details API endpoint. Any user with valid credentials can view deployment information for teams they don't belong to, exposing sensitive infrastructure and application details across team boundaries. The flaw stems from the endpoint accepting a team identifier from the user's authentication token but failing to validate that the requested deployment actually belongs to that team.

• CVE-2026-28385MEDIUM 5.0

  Canonical LXD has a weakness in how it handles image imports that allows authenticated users to scan internal networks and reach services they shouldn't be able to access. When someone with image-creation permissions requests LXD to import a container image from a URL, the daemon doesn't properly check where that URL points. This means an attacker could probe internal IP ranges, connect to localhost services, or reach cloud metadata endpoints that should be off-limits. The vulnerability requires authentication and specific permissions, which limits exposure, but it's a meaningful network reconnaissance and lateral-movement risk in shared or cloud-hosted LXD environments.

• CVE-2026-34167MEDIUM 5.0

  Coolify, an open-source platform for managing servers and applications, contains an authorization flaw in its ActivityMonitor component. An authenticated user can view activity logs and command output from other teams by guessing sequential activity IDs. This could expose sensitive data like SSH credentials, database passwords, and infrastructure configuration details. The vulnerability affects all versions before 4.0.0-beta.471 and is fixed in that release.

• CVE-2026-35188MEDIUM 5.0

  A flaw in OpenSSL's handling of TLS OCSP stapling—an optimization that allows servers to provide certificate validity proof directly—can cause a double-free memory error in connecting clients. When a malicious server sends a specially crafted OCSP response, it triggers corruption of the client's heap memory. While OCSP stapling is disabled by default, organizations that have explicitly enabled it face exposure. The vulnerability reliably causes denial of service; remote code execution is theoretically possible but difficult to reliably achieve in practice.

• CVE-2026-40992MEDIUM 5.0

  Spring Boot's automatic email configuration leaves mail server connections vulnerable to man-in-the-middle attacks by not verifying the server's identity by default. An attacker positioned on the network path between an application and its mail server could intercept and manipulate email traffic. However, applications that explicitly enable hostname verification through JavaMail properties are protected from this risk.

• CVE-2026-41977MEDIUM 5.0

  CVE-2026-41977 is a denial-of-service vulnerability in a log service that can be triggered by local attackers with minimal privilege requirements. The flaw stems from an integer overflow condition (CWE-190) and may be exploited through user interaction to disrupt system availability and cause minor data integrity issues. While the attack requires local access and user action, the scope crosses security boundaries, making it relevant to systems where unprivileged local accounts or guest access exists.

• CVE-2026-42862MEDIUM 5.0

  Flowise, a popular drag-and-drop interface for building custom AI language model workflows, contains a security flaw that allows authenticated users to move tools between workspaces without proper authorization. When updating a tool, the application fails to validate who should have permission to change ownership fields like workspaceId. An attacker with legitimate access to one workspace can reassign tools to a different workspace, potentially exposing or stealing AI workflows, data pipelines, or proprietary configurations belonging to another team or customer. This breaks the isolation that multi-workspace Flowise deployments rely on to keep organizations separate.

• CVE-2026-43979MEDIUM 5.0

  Local Deep Research versions before 1.6.0 contain a vulnerability where user-supplied search queries and metadata are inserted directly into HTML without proper escaping before being converted to PDF. An authenticated user can inject HTML tags that trick the server into making unauthorized web requests (SSRF), bypassing existing security controls. The vulnerability requires valid credentials but poses moderate risk due to potential confidentiality impact.

• CVE-2026-44173MEDIUM 5.0

  MariaDB server versions within specific ranges contain a privilege-escalation flaw that allows authenticated users to write files to the server's filesystem without possessing the FILE privilege. The vulnerability exists when SELECT statements direct output to files (using INTO OUTFILE or INTO DUMPFILE) and the FROM clause references only subqueries, bypassing the privilege check. An attacker with database login credentials but no explicit FILE permission can exploit this to write arbitrary content to disk, potentially compromising system integrity or enabling further attacks.

• CVE-2026-44936MEDIUM 5.0

  SUSE Rancher Fleet, a Kubernetes fleet management tool, contains a credential leakage vulnerability in how it handles Helm repository authentication. When administrators configure fleet bundles with Helm repositories but don't explicitly set URL validation rules (helmRepoURLRegex), the system will forward stored authentication credentials to any repository URL specified in a fleet.yaml file. An attacker with push access to a monitored Git repository can exploit this by adding a malicious Helm repository URL to a fleet configuration, causing the system to transmit BasicAuth credentials to that attacker-controlled endpoint. This allows credential theft without modifying legitimate configurations.

• CVE-2026-45407MEDIUM 5.0

  Dokku, a containerized platform-as-a-service tool, inadvertently exposes git credentials to local users when setting up authentication. The vulnerability exists in versions before 0.38.2, where a shell command used to initialize credential storage files doesn't set secure file permissions, leaving git authentication tokens readable by anyone with local system access. This is a local privilege escalation and credential theft risk specific to multi-user Dokku deployments.

• CVE-2026-45502MEDIUM 5.0

  A server-side request forgery (SSRF) vulnerability in Microsoft Exchange Server allows an authenticated attacker to make the server issue requests on their behalf, potentially exposing sensitive network information. An attacker with valid credentials can craft requests that cause the Exchange server to connect to internal resources and leak data back to them. This requires prior authentication but poses a meaningful information disclosure risk within trusted network boundaries.

• CVE-2026-46526MEDIUM 5.0

  Local Deep Research versions before 1.6.10 contain a Server-Side Request Forgery (SSRF) vulnerability caused by inconsistent URL validation logic. The application attempts to block malicious URLs using one parsing method but actually sends requests using a different method, creating a gap that attackers can exploit. An authenticated user can craft a specially formatted URL that passes the security checks but reaches an unintended internal or restricted server when the request is actually sent.

• CVE-2026-46561MEDIUM 5.0

  pyLoad, a popular open-source download manager, contains a vulnerability that allows authenticated users to bypass security controls designed to prevent access to internal networks. Specifically, an attacker can craft a specially designed URL that initially appears safe but redirects to a private IP address after the security check passes. This lets the attacker potentially access or interact with systems on the internal network that should be off-limits. The issue affects versions prior to 0.5.0b3.dev100 and has been resolved in that release.

• CVE-2026-48096MEDIUM 5.0

  OpenFGA, an authorization engine used by developers to control permissions, has a caching flaw that could cause it to reuse incorrect permission decisions. When iterator caching is enabled, two different permission requests can accidentally use the same cached result, potentially allowing or denying access incorrectly. The issue affects versions before 1.16.0 and has been patched.

• CVE-2026-48770MEDIUM 5.0

  Notepad++ versions before 8.9.6.1 contain a local denial-of-service vulnerability where a malicious process running on the same Windows session can crash the application by sending a specially crafted message. The vulnerability stems from improper validation of inter-process communication data, allowing an attacker to trigger a memory access violation without requiring special privileges beyond standard user-level access.

• CVE-2026-48956MEDIUM 5.0

  Joomla! contains an access control weakness that allows authenticated users to view a list of installed modules through the frontend interface. While an attacker needs valid login credentials to exploit this, the improper permission check exposes internal system information that should remain hidden from regular users. This information disclosure could help an attacker plan more targeted attacks against the application.

• CVE-2026-49138MEDIUM 5.0

  Nanobot versions prior to 0.2.1 contain a server-side request forgery (SSRF) vulnerability in its web_fetch tool. An attacker with login credentials can trick the application into making requests to internal or private network systems by providing a URL that redirects to a loopback address (like 127.0.0.1) or private IP range. The vulnerability exploits how the underlying httpx library automatically follows HTTP redirects—the application validates the initial URL but not the final destination after redirects are followed, allowing attackers to reach internal services that should not be accessible from the internet.

• CVE-2026-49433MEDIUM 5.0

  DeepAI's email change endpoint lacks CSRF (Cross-Site Request Forgery) protection, allowing attackers to hijack user accounts. An attacker who tricks a logged-in user into visiting a malicious link can silently change that user's email address, potentially locking the legitimate owner out and enabling account takeover. The vulnerability was patched on May 20, 2026.

• CVE-2026-49958MEDIUM 5.0

  Hermes WebUI versions prior to 0.51.303 contain a race condition vulnerability in its file deletion functionality. An attacker with local access and user privileges can exploit a timing gap between when the application validates a file path and when it actually deletes it. By swapping a directory component with a symbolic link at just the right moment, an attacker can trick the application into deleting files outside the intended workspace—potentially removing important system or application files. This requires precise timing and user interaction but could lead to significant data loss or system disruption.

• CVE-2026-54055MEDIUM 5.0

  Kitty, a popular GPU-accelerated terminal emulator, contains a local privilege escalation flaw in its file transmission protocol affecting versions before 0.47.2. A low-privileged user running a child process in the terminal can write files to arbitrary locations on the system by exploiting a race condition in how Kitty validates and creates files. An attacker would need local access and user interaction, but the window for exploitation is small and doesn't require special privileges to trigger.

• CVE-2026-54786MEDIUM 5.0

  Wasmtime, a WebAssembly runtime, contains a resource leak in its implementation of the WASIp1 file descriptor renumbering function (fd_renumber). When a WebAssembly guest program renumbers a file descriptor, Wasmtime updates its internal descriptor table but fails to clean up the corresponding entry in the host operating system's file descriptor table. This leaves orphaned file descriptors and other resources that accumulate in the host until the entire Wasmtime Store is destroyed. An attacker with the ability to execute WebAssembly code and access file descriptors can deliberately call fd_renumber in a loop to exhaust the host's file descriptor pool and memory, causing a denial of service. The vulnerability requires authenticated access (file descriptor capability) and affects only runtimes that expose both fd_renumber and file access to guest modules.

• CVE-2026-55655MEDIUM 5.0

  OpenSSH on Linux has a vulnerability that allows a local attacker to intercept and potentially manipulate X11 graphical display traffic forwarded over SSH. By pre-creating a socket file in a predictable location, an unprivileged user on the same machine can hijack the connection before the SSH client establishes it, gaining access to sensitive window contents, keyboard input, and other display data. The attack requires the victim to have X11 forwarding enabled and an active SSH session, but does not require elevated privileges.

• CVE-2026-56399MEDIUM 5.0

  Open WebUI versions prior to 0.6.27 contain a flaw that allows authenticated users to access internal services on the same network as the application. An attacker with valid credentials can craft specially formed web requests that bypass the application's safeguards against server-side request forgery (SSRF), potentially reaching backend systems and sensitive configurations that should be off-limits. This is particularly concerning because it chains authentication with network access to internal resources.

• CVE-2026-56777MEDIUM 5.0

  n8n, a popular workflow automation platform, contains a security flaw in its Python Code node that allows authenticated users to bypass safety checks and access underlying system modules. This vulnerability only affects self-hosted instances where Python task execution is enabled and environment variable access is permitted. An attacker with workflow creation permissions could potentially read sensitive environment variables that the task runner process can access, such as API keys or database credentials.

• CVE-2026-57282MEDIUM 5.0

  Jenkins Git client Plugin versions 6.6.0 and earlier contain a command injection flaw in how they construct SSH wrapper scripts. When a Jenkins build runs in a workspace with a specially crafted directory name, an attacker with the ability to influence that workspace path can inject arbitrary shell commands that execute on the Jenkins agent. This requires authenticated access to create or influence build job workspace naming, limiting immediate risk but creating a significant privilege-escalation vector in multi-tenant Jenkins environments.

• CVE-2026-57439MEDIUM 5.0

  CyberChef, a popular web application for data encryption, encoding, and analysis, contains a vulnerability in its Series Chart operation that allows an attacker to inject malicious code. By crafting a specially formatted CSV file with a `__proto__` key, an attacker can exploit prototype pollution—a JavaScript technique that modifies object prototypes—to insert harmful JavaScript that gets executed when the data is rendered in HTML. This requires user interaction (opening/uploading a file) but can compromise the security of the application and potentially affect downstream operations like UDP packet parsing.

• CVE-2026-58057MEDIUM 5.0

  Flowise, a visual AI workflow platform, contains a vulnerability in how it validates environment variables for custom integrations on Windows systems. Attackers with legitimate access to configure workflow nodes can bypass security restrictions by using a lowercase variant of a blocked environment variable, allowing them to execute arbitrary code on the Flowise server. This requires authentication and administrator-level access to the workflow configuration interface.

• CVE-2026-59100MEDIUM 5.0

  LobeChat versions up to 2.2.9 suffer from a broken authorization flaw that allows authenticated users to view, modify, and delete chat agent data belonging to other users. By guessing or knowing other users' group identifiers, an attacker with valid login credentials can manipulate agent configurations in groups they don't own, effectively hijacking or disabling shared chat automation workflows without detection or consent.

• CVE-2026-59152MEDIUM 5.0

  The LangSmith Client SDKs contain a vulnerability in their TracingMiddleware component that allows an attacker to read arbitrary files from a server and secretly upload them to LangSmith. An attacker with read access to a LangSmith workspace—such as a low-privilege team member, contractor, or compromised account—can exploit this to access files on any server running the vulnerable middleware, even without direct server access. This breaks the intended security boundary by granting file-read capabilities beyond what workspace permissions should allow. The vulnerability affects all LangSmith SDK versions before 0.8.18.

• CVE-2026-59253MEDIUM 5.0

  n8n, a workflow automation platform, contains a flaw in how it checks permissions when users create or modify workflows. An authenticated user can craft specially-formatted requests to place workflows into folders belonging to other projects—even if they shouldn't have access to those projects. This is a logical integrity issue rather than a confidentiality breach; no data is exposed, but folder organization and project boundaries can be violated.

• CVE-2026-6891MEDIUM 5.0

  A vulnerability in My Image Garden for macOS version 3.6.8 and earlier allows a logged-in user to manipulate the installer through specially crafted symbolic links, potentially gaining permission changes to files they shouldn't normally access. This is a local privilege escalation risk that requires both system access and user interaction during installation.

• CVE-2026-6892MEDIUM 5.0

  A flaw in Canon's CUPS printer driver installers for macOS allows a local attacker who has login access to a machine to manipulate symbolic links during the installation process. By crafting a malicious symbolic link, an attacker can trick the installer into changing file permissions on directories they shouldn't normally be able to modify. This is a local-only attack that requires an attacker to already have user-level access to the system.

• CVE-2026-9903MEDIUM 5.0

  Google Chrome versions prior to 148.0.7778.216 contain a vulnerability in Site Isolation, a security feature designed to prevent malicious websites from accessing data from other sites you visit. An attacker who has already compromised Chrome's renderer process—the part that interprets web content—can craft a specially designed MHTML file (a web archive format) that bypasses this protection. This requires the attacker to have gained initial access to the renderer process and the user to open the malicious file, but if successful, it could allow unauthorized access to sensitive information across site boundaries.

• CVE-2026-9942MEDIUM 5.0

  CVE-2026-9942 is a memory safety issue in ANGLE, the graphics abstraction layer used by Google Chrome. When a remote attacker has already compromised Chrome's renderer process, they can exploit this uninitialized memory condition to break out of Chrome's site isolation sandbox using a specially crafted HTML page. Site isolation is Chrome's primary defense against cross-site data theft; bypassing it allows an attacker to read data from other websites the user is visiting. This requires the renderer process to be already compromised, meaning it is a post-compromise escalation rather than an entry point.

• CVE-2026-9979MEDIUM 5.0

  CVE-2026-9979 is a site isolation bypass vulnerability in Google Chrome that allows an attacker to escape the security boundary between different websites if they have already compromised Chrome's rendering engine. An attacker would need to trick a user into visiting a malicious HTML page while the renderer process is already under their control. Site isolation is Chrome's core defense mechanism that prevents one website's scripts from accessing another website's data; this vulnerability undermines that protection in a limited but serious scenario.

• CVE-2026-9980MEDIUM 5.0

  Google Chrome versions before 148.0.7778.216 contain a flaw in how it validates input when printing documents. An attacker who has already compromised Chrome's rendering engine can exploit this to bypass Site Isolation, a security boundary that separates data between websites. This requires both a prior compromise of the renderer process and user interaction, making it a secondary attack in a chain rather than a standalone entry point.

• CVE-2025-64719MEDIUM 4.9

  Gogs, a self-hosted Git service, contains a flaw that allows users with file creation permissions to crash the repository or wiki interface. When a user creates a file, the system attempts to retrieve commit history for the listing pages. If that retrieval fails, the entire page fails with an HTTP 500 error instead of handling the error gracefully. This makes the file listing unusable until the issue is resolved. The vulnerability affects Gogs versions before 0.14.3.

• CVE-2026-0285MEDIUM 4.9

  A vulnerability in Palo Alto Networks PAN-OS allows authenticated administrators with access to the management interface to make unauthorized requests from the firewall itself to internal services. This server-side request forgery (SSRF) flaw could enable an admin to pivot toward backend systems or services that should only be reachable from within the firewall's network. The risk is materially reduced if you follow Palo Alto Networks' recommended practice of restricting management interface access to trusted internal IP addresses only.

• CVE-2026-10039MEDIUM 4.9

  The Frontend Admin plugin for WordPress contains a SQL injection vulnerability that allows authenticated administrators to extract sensitive data from the website's database. The flaw exists in how the plugin processes the 'order' parameter—it fails to properly escape user input before inserting it into database queries. An attacker with administrator privileges can craft a malicious request containing both 'order' and 'orderby' parameters to inject additional SQL commands and retrieve unauthorized information. This vulnerability affects all versions up to and including 3.28.28.

• CVE-2026-10074MEDIUM 4.9

  DreamMaker, a product developed by Interinfo, contains a vulnerability that allows authenticated administrators or privileged users with local access to read arbitrary files from the system. An attacker with elevated privileges can exploit a path traversal flaw to access sensitive system files they shouldn't normally be able to retrieve, potentially exposing configuration data, credentials, or other protected information.