FreeRTOS-Kernel V11.3.0 and V11.3.1 contain an incorrect-authorization flaw (CWE-863) in the Memory Protection Unit port for the Arm Cortex-R82 (Armv8-R AArch64), allowing an unprivileged task on MPU-enabled builds to read and write privileged kernel memory outside the regions assigned to it via a buffer argument passed to an MPU system call. Exploitation is strictly local: the attacker must already be able to execute an unprivileged task on the device and invoke an MPU system call with an attacker-controlled buffer argument (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), so remote/network reach and non-MPU or non-Cortex-R82 builds are unaffected. No public exploit code was identified at time of analysis and the issue is not in CISA KEV, but the flaw is fully fixed in V11.3.2, which is the recommended upgrade target.
Numeric truncation in the MPU buffer authorization check in FreeRTOS-Kernel V11.3.0 and V11.3.1 on the Arm Cortex-R82 (Armv8-R AArch64) MPU port allows an unprivileged task running on an MPU-enabled build to read or write privileged kernel memory beyond the validated buffer window by issuing a stream buffer system call. Exploitation requires a narrow configuration: an MPU-enabled build on that specific AArch64 port at those two versions, plus pre-existing ability to execute an unprivileged task that can make stream buffer calls - there is no remote vector, and the affected hardware port is new and narrowly deployed. No public exploit code has been identified at time of analysis and the flaw is not confirmed as actively exploited (not in CISA KEV); the vendor has released V11.3.2 to remediate it.
Argument injection in the Claude Agent SDK for Python (claude-agent-sdk) before 0.2.121 allows remote attackers to achieve arbitrary command execution when an embedding application passes untrusted input into the SDK's `resume` option. Because `--resume` is declared by the Claude CLI with an optional value, a session identifier beginning with `-` is parsed as a separate CLI flag rather than the option's value, letting an attacker inject `--mcp-config` and register a stdio MCP server that executes arbitrary commands at CLI startup while bypassing the SDK's permission controls. The assessed CVSS:3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) indicates no authentication is required but exploitation is high-complexity and conditional on the host application forwarding attacker-controlled data as the session ID; a vendor patch is available as version 0.2.121, and no public exploit code was identified at time of analysis.
An unauthenticated stack-based buffer overflow in the Boa web server embedded in Netcore NR256CN firmware through 1.5.140116 lets remote attackers crash the router's main Boa process - and potentially execute code - by sending an HTTP Basic-auth username longer than 63 bytes to any password-protected /router/*.cgi route. The defect lives in the pre-authentication user_ok() handler, where Basic-auth usernames are copied with unbounded strcpy() into a fixed 64-byte stack buffer, so exploitation requires no credentials and no user interaction; the practical risk is governed almost entirely by exposure, since the attacker must be able to reach the device's HTTP management interface (far more dangerous when it faces the WAN, far less so when confined to the LAN). Per available data there is no confirmed active exploitation in CISA KEV and no public exploit code identified at time of analysis, but the zero-prerequisite access path and the network-facing attack vector make this a high-priority issue for any NR256CN with an internet-reachable admin UI.
Unauthenticated administrative account creation in WhaTicket Community through commit cf04795 allows remote attackers to self-register as administrators via POST /auth/signup by omitting the profile field or setting it to admin. Successful exploitation grants control over user management, settings, and all tickets, contacts, messages, and WhatsApp connections. The flaw is unauthenticated and network-reachable under the assessed CVSS:3.1 vector, but no CISA KEV active exploitation is confirmed and no public exploit is explicitly identified at time of analysis, although a public technical writeup reference exists.
Authentication bypass in the DataBuff ai-apm-web module through version 0.1.10 lets unauthenticated remote attackers forge administrative JWT session tokens because the application ships and consumes a hardcoded HMAC signing secret ('dev-secret') in JwtTokenService. An attacker who knows that default key can mint a token claiming the admin role with a future expiry and gain full administrative access to protected /webapi routes, most critically the Doris SQL query API, yielding high confidentiality, integrity, and availability impact (vendor score 9.3; independently assessed CVSS:3.1 base 9.8 with PR:N, no privileges or user interaction required). Exploitation is conditional on the deployment retaining the shipped default secret: any instance that has replaced it with a unique strong value is not exploitable through this path. This CVE is not listed in CISA KEV and no public exploit code was identified at time of analysis, though a third-party technical write-up describing the flaw is publicly referenced; note that classic HS256/JWT signing bypasses are trivial to script once the key is known, so the absence of a packaged exploit should not be treated as meaningful protection.
Unauthenticated remote code execution in WeRSS (we-mp-rss) through 1.5.3 allows any attacker who can reach the public GET /rss/{feed_id} endpoint to run arbitrary OS commands as the service account. The flaw is a server-side template injection (CWE-95) in the template parser: by supplying a non-built-in ext value together with a {{=expression}} template, an attacker uses object-subclass traversal to bypass the eval denylist and reach command execution, with no authentication, user interaction, or non-default configuration required. Reported CVSS is 9.3 (CVSS 4.0, AV:N/AC:L/AT:N/PR:N/UI:N) and our independent assessment confirms remote, unauthenticated exploitation with high confidentiality, integrity and availability impact, rating this a genuine high-priority vulnerability rather than a high-CVSS-but-low-real-risk case; no public exploit code was identified at time of analysis, though a public technical writeup of the exploitation chain and a VulnCheck advisory are referenced.
Unauthenticated account takeover in IceCMS through 4.1.5 allows remote attackers to modify, disable, or delete any account, including administrators, by sending PUT requests to /User/updateUser and setting a new password and role for an arbitrary userId. The root cause is that the /User/** path is excluded from the Shiro JWT authentication filter, so no valid session, token, or credentials are required when the backend user-management endpoints are reachable. It is critical severity (CVSS 9.3; independently assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), and no public exploit identified at time of analysis.
Unauthenticated attackers can obtain a valid JWT session for any account - including superusers - in FastapiAdmin through 3.0 by abusing auto-login endpoints that ship without authentication checks. The attack chain is straightforward: enumerate accounts via /api/v1/auth/auto-login/users, mint a superuser auto-login token, then exchange that token for a full JWT session granting complete administrative control of the application. Exploitation requires only network reachability to the admin API with no credentials, no user interaction, and no non-default configuration, and the referenced public writeup also notes a hardcoded JWT signing secret that further undercuts token-based defenses; no vendor-released patch was identified at time of analysis, and no public exploit code was confirmed.
Unauthenticated attackers can seize full administrative control of Webreaper Damselfly deployments through version 4.5.3 because the authorization attributes on the REST API controllers were shipped commented out, leaving every /api/* route reachable without credentials. An attacker can send PUT /api/users with an Admin role to create their own administrator account, or POST /api/users to reset any existing user's password, then use that access to read, modify, or destroy the entire photo library and its configuration. The flaw is rated CVSS 4.0 9.3 (AV:N/AC:L/AT:N/PR:N/UI:N, VC:H/VI:H/VA:H) and classified as CWE-306; no public exploit identified at time of analysis, although a public technical writeup of the missing authorization, the upstream GitHub issue, and a VulnCheck advisory are referenced.
Unauthenticated information disclosure in the MAIO WordPress plugin before version 7.3.22 allows any remote attacker to retrieve the plugin's stored crawl-analytics log - including each recorded visitor's IP address, user agent, and referer - by presenting a credential value that ships verbatim in the plugin's own publicly distributed source as a valid API key. Because the accepted key is readable by anyone who downloads the plugin, there is effectively no authentication barrier: the CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms remote, unauthenticated exploitation with no user interaction, and no non-default configuration is required beyond the analytics logging being in use so that records exist. Publicly available exploit code exists via the WPScan advisory; the impact is confined to telemetry disclosure with no integrity or availability effect, giving a moderate CVSS score of 5.3.
Server-side request forgery in Chaskiq through 2.0.3 allows unauthenticated attackers to make the server fetch arbitrary URLs-including internal network resources and cloud instance metadata endpoints-by submitting crafted requests to the createUrlUpload GraphQL mutation. The fetched content is stored as an ActiveStorage blob and returned to the attacker, enabling exfiltration of sensitive data such as IAM credentials from IMDSv1 endpoints. With a CVSS 9.2 severity and no authentication required, this is a high-priority issue; at time of analysis, no public exploit code was identified, though a technical writeup is publicly available. Note: confirmed actively exploited (CISA KEV) is not applicable; no public exploit identified at time of analysis.
Improper verification of the source of IPv6 Router Advertisements in Amazon FreeRTOS-Plus-TCP before V4.4.2 allows an unauthenticated attacker on the same local link to send crafted Router Advertisements and influence a device's IPv6 default gateway, on-link prefix, and address configuration, potentially redirecting or intercepting IPv6 traffic (assessed CVSS:3.1 vector AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L). Exploitation requires IPv6 Router Advertisement/autoconfiguration processing to be enabled and the attacker to be positioned on the same link, because RAs are link-local ICMPv6 multicast messages that are not routable; no authentication or user interaction is required. No public exploit code has been identified at time of analysis and CISA KEV does not list this CVE; the vendor has released patch V4.4.2.
Authentication bypass in OpenBMB StaffDeck through 0.5.6 lets unauthenticated attackers forge valid administrator session tokens by signing an HMAC-SHA256 token with the hard-coded default app_secret shipped in backend/app/config.py, targeting the seeded 'admin' user in the 'tenant_demo' tenant. Successful exploitation grants full tenant administration, including access to stored model and channel credentials; the assessed CVSS 3.1 score is 9.2 (Critical) with AV:N/PR:N/UI:N but AC:H/AT:P, because only deployments that have not rotated the default secret and that still retain the demo tenant and admin account are affected. No public exploit identified at time of analysis, and no CISA KEV entry or vendor-patched version was provided in the source data.
Python code injection in SGLang 0.5.10 through 0.5.22 allows unauthenticated remote attackers to escape an eval() sandbox in the _evaluate_filter() helper and execute arbitrary Python in the scheduler process. Exploitation is strongly gated: the optional debug dumper server must be explicitly enabled by setting the DUMPER_SERVER_PORT environment variable, which is what exposes the unauthenticated /dumper/configure endpoint; default deployments do not enable it. Once the endpoint is reachable, a crafted filter expression is stored and runs on the next forward pass, giving full code execution with high confidentiality, integrity, and availability impact; no vendor-released patch has been identified at time of analysis, and no public exploit code was identified at time of analysis.
Unauthenticated attackers can take over accounts on Course Tencent Cloud versions 2.0.1 and earlier by brute-forcing 6-digit SMS/email verification codes that are never invalidated or attempt-limited. Exploitation requires knowledge of the victim's registered phone number or email address and rotation of source IPs to bypass per-IP rate limiting, as the codes have no per-account attempt counter. No public exploit code or active exploitation has been identified at time of analysis.
Authentication bypass in WIMOOR through commit ec86736 allows remote attackers to impersonate any tenant and privilege level by forging an unsigned X-USERINFO header, enabling read and modification of other tenants' orders, finance data, and Amazon seller authorizations. Exploitation requires direct network access to backend service ports, bypassing the API gateway that normally signs the header; deployments where backend ports are segmented/firewalled are not exploitable. The assessed CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N) captures this high-severity impact but gated by network positioning, and no public exploit has been identified at time of analysis.
Integer overflow in RIOT OS nanocoap CoAP server allows remote unauthenticated attackers to trigger out-of-bounds memory access, denial of service, or memory corruption by sending a crafted Block2 option with a block number exceeding the 20-bit maximum. Affected versions are prior to 2026.07, specifically builds around master baseline commit aeeae69e on 32-bit targets. No public exploit code or active exploitation has been identified at time of analysis. The CVSS 3.1 base score is 9.1 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H).
Authenticated path traversal in Thermo Fisher Torrent Suite Software lets a user who already holds a valid low-privilege session on the Torrent Server web interface read arbitrary files that are accessible to the web service account. Per the assessed CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), impact is confidentiality-only - no write, integrity, or code-execution effect - and the readable scope is bounded by the filesystem permissions of the web service account, so it cannot reach files that account cannot access. No public exploit code or confirmed active exploitation was identified at time of analysis, and the authentication prerequisite confines realistic risk to insiders or attackers who have already obtained credentials; this is a moderate-priority information-disclosure issue rather than a critical emergency. CISA published an ICS medical advisory (ICSMA-26-288-01) covering this flaw.
Authenticated OS command injection in the WP Photo Album Plus WordPress plugin (all versions up to and including 9.3.02.002) lets any WordPress user granted the plugin-defined wppa_upload capability execute arbitrary operating-system commands as the web-server user, achieving full server-side code execution where ImageMagick is the active image backend. Rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), the flaw is reachable through the update-photo AJAX action's value parameter, and no public exploit code was identified at time of analysis; the bug is not in CISA KEV. Because wppa_upload is a plugin-level privilege that administrators can delegate to lower-privileged roles, the effective attacker pool can extend well beyond site administrators on misconfigured sites.
Stored cross-site scripting in the Countly Server star-rating plugin allows an authenticated, non-global application administrator to upload attacker-controlled active content (for example an HTML/JS file disguised as an image) through the uploadFeedbackFile endpoint, which pre-patch trusts the client-supplied MIME type. The file is then publicly served from feedback/preview/ with that attacker-influenced Content-Type, so a global administrator who opens the feedback preview executes the payload in the Countly origin and can expose authenticated session material such as auth_token and csrf_token values. Rated CVSS 3.1 9.0 (AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:H), exploitation requires app-admin credentials plus the higher-privileged victim actively opening the preview, and no public exploit code has been identified at time of analysis.
Remote command execution in ZoneMinder prior to 1.38.3 allows an authenticated user with monitor-create or monitor-edit rights to store a monitor Name containing shell metacharacters that break out of manual single-quote wrapping when a user with Events View permission exports that monitor's events, executing arbitrary commands as the web server user. Exploitation requires two authenticated roles and victim interaction (CVSS vector PR:L/UI:R), so this is not a default-reachable or mass-exploitable issue; no public exploit identified at time of analysis, and a vendor-released patch is available in 1.38.3.
OS command injection in Apache Kylin 4.0.4 through 5.0.4 lets a remote attacker who holds valid low-privilege credentials (CVSS PR:L, UI:N) execute arbitrary operating system commands on the Kylin host, with high confidentiality, integrity and availability impact under an 8.8 base score. The vendor is explicit that meaningful exposure requires the Kylin service to be directly reachable from the public network, an uncommon configuration, and that typical in-house deployments are mostly unaffected. EPSS is only 1.03% (63rd percentile) and no public exploit code or CISA KEV listing was identified at time of analysis, so the realistic priority is lower than the raw CVSS suggests, and exploitation is not confirmed in the wild.
Remote code execution via arbitrary file upload affects the YaySMTP WordPress plugin in all versions up to and including 2.7.7, where an authenticated subscriber-level user can upload executable files through the putFile function. The plugin relies on sanitize_file_name() without an allow-list, MIME check, or safe-extension rename, and its only server-side guard is a .htaccess file with 'Require all denied' that nginx and Apache with AllowOverride None ignore, so full RCE is achievable on those configurations. No public exploit code was identified at time of analysis and there is no confirmed CISA KEV active exploitation; exploitation requires authentication at subscriber level or above, which is commonly available when open user registration is enabled.
Authenticated low-privileged users on MariaDB Server can hijack any account they can name, because GRANT PROXY mis-evaluates grantor privileges when the statement carries an IDENTIFIED (VIA) clause with an empty password. Under those conditions the server treats the statement as though no authentication clause had been supplied, checks the wrong grantor's rights, and lets the attacker set the target account's password - so an ordinary login can be escalated to full control of a privileged account. All builds from 10.6.1 up to the fixed releases 10.6.28, 10.11.19, 11.4.13, 11.8.9, 12.3.3 and 13.0.2 are affected; no public exploit identified at time of analysis, and no user interaction is required (CVSS 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H).
Arbitrary file upload in the DoubleScale All-in-One CRM WordPress plugin through version 1.5.1 allows authenticated attackers with subscriber-level access or higher to upload executable PHP files when the Helpdesk module is enabled, which can lead to remote code execution. The flaw is an unrestricted upload issue (CWE-434) with a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), and no public exploit was identified at time of analysis. The assessed exploitation conditions require both a valid low-privilege WordPress account and an active Helpdesk module, making the risk highest on sites that allow open user registration.
Device ownership takeover and serial ID disclosure in the eSeeCloud cloud platform lets unauthenticated remote attackers rebind a target device to their own account even when that device is actively bound to a different owner, exposing the device's full serial ID. The flaw is server-side only: the bind/unbind workflow accepts the rebind request without verifying that the requester currently owns the device, so no credentials, configuration change, or user interaction are required (CVSS 4.0 base 6.9, AV:N/AC:L/PR:N/UI:N, C:L; assessed CVSS 3.1 6.5 with I:L as well). It was reported to CISA by ICS-CERT as advisory ICSA-26-288-02 and is classified as an information disclosure issue; there is no indication of confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis.
Enumeration of registered surveillance devices in the eSeeCloud platform allows anyone who already holds a valid access token to distinguish live 10-digit device IDs from unassigned ones, because the endpoint returns a distinct error response for nonexistent IDs compared with registered ones and applies no meaningful rate limiting, making discovery of registered devices at scale practical. The reporter rates this CWE-204 observable response discrepancy 6.9 under CVSS 4.0, while our reassessment scores it CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N - authenticated, network-reachable, low-complexity enumeration with confidentiality-only impact, no data content disclosure, no modification and no device control. Published through CISA ICS-CERT as ICSA-26-288-02; no public exploit code identified at time of analysis, no CISA KEV listing, and no EPSS data was supplied.
Authenticated OS command injection in ZoneMinder versions prior to 1.38.3 allows a low-privilege user holding View Events or View Snapshots permission to run arbitrary operating system commands as the web server user. The flaw lives in exportEvents() in web/skins/classic/includes/export_functions.php, where the attacker-controlled exportFile request parameter is appended to a tar or zip command executed via exec() without shell escaping, so a crafted value can break out of the trailing directory argument. Exploitation requires a valid session (CVSS PR:L), a valid CSRF token for the export request, and the exportDetail option enabled; no public exploit code has been identified at time of analysis, and there is no confirmed active exploitation (CISA KEV), though the vendor's own GHSA advisory and fix commits confirm the issue is real and the EPSS-style risk is elevated by the low privilege threshold and high confidentiality, integrity, and availability impact (CVSS 8.8).
Authenticated attackers with Subscriber-level or higher PilotPress membership on WordPress sites can escalate to full Administrator privileges by exploiting a flawed ONTRAPORT synchronization routine in PilotPress versions up to and including 2.0.43. The defect allows an attacker to rename a remote ONTRAPORT contact to an existing Administrator's WordPress login, then leverage the plugin's authentication hook to cause WordPress core to issue an Administrator authentication cookie. This is a genuine high-priority vulnerability (CVSS 8.8), requiring a valid ONTRAPORT contact and the Customer Center nonce, but no victim interaction. No public exploit code was identified at time of analysis.
Authentication bypass in ZKEACMS through 4.4 allows unauthenticated remote attackers to forge their own admin-level REST API JSON Web Tokens, because the HMAC-SHA256 key used to validate bearer tokens is hard-coded in JwtBearerDefaults.cs and is therefore identical on every installation. An attacker who signs a token with the Name claim set to 'admin' can call ApiAuthorize endpoints to modify articles and products and to read submitted form data, producing high integrity impact with limited confidentiality exposure (vendor CVSS 4.0 score 8.8; independently assessed as CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:L, i.e. unauthenticated and network-reachable). Neither CISA KEV nor a packaged exploit was reported in the provided intelligence, but the signing key is published in the project's public source repository and a public write-up describes the technique, so forgery is trivial for anyone who can reach the API; the main practical limiter is whether the REST API is exposed.
Unauthenticated configuration takeover of ChronoFrame 1.0.0 and earlier lets any attacker who can reach the HTTP service POST to the setup-wizard API and repoint instance storage to an attacker-controlled S3 or OpenList backend while overwriting site and map settings. The flaw covers every release through 1.0.0 (CPE cpe:2.3:a:hoshinosuzumi:chronoframe:*:*:*:*:*:*:*:*) and remains exploitable on instances where initial setup is already complete, because the /api/wizard/ handlers enforce neither authentication nor a setup-complete check. No public exploit identified at time of analysis and no CISA KEV entry, though a public technical writeup describes the attack path; the independent assessment (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:L) rates this high priority for any network-exposed deployment.
Delegated 'users:update' permission in Arcane (getarcaneapp/arcane) 2.5.0 and earlier allows an authenticated holder of that permission to overwrite the global administrator's password via PUT /users/{adminId} and then authenticate as the admin, achieving complete administrator account takeover. The UpdateUser handler (backend/api/handlers/users.go:317-323) and the underlying user service (user_service.go:174) set the target user's PasswordHash from the request body and Save unconditionally, with no comparison of caller privilege against target privilege, even though users:update is deliberately intended to sit below the RequireGlobalAdmin-gated role assignment and role CRUD operations. Exploitation is remote, requires no user interaction, and needs no extra configuration beyond the precondition that an administrator has created a custom role (e.g. 'User Manager') containing users:update and assigned it to the attacker's account; deployments that never delegate that permission are not exposed, and no public exploit was identified at time of analysis (CVSS 8.8, PR:L).
Code injection in Apache Kylin 4.0.0 through 5.0.4 allows an authenticated low-privilege user who can supply or influence a JDBC connection URL to inject a crafted special parameter and execute arbitrary code. The vendor limits practical exposure to Kylin services directly reachable from the public network, noting that in-house deployments are mostly unaffected; no public exploit code has been identified at time of analysis and EPSS is low at roughly 0.23%.
Prompt injection in DeepSeek Harness (dsh), at commit c291e796, allows attacker-crafted external content to hijack the harness's context-compaction feature so that malicious instructions are executed when that content is summarized and compacted into the working context. Exploitation requires the victim to run the harness and cause compaction to process the attacker-controlled material (UI:R), but no privileges are needed by the external-content attacker (PR:N), and successful abuse can compromise confidentiality, integrity and availability of the developer's session and its tooling at CVSS 3.1 8.8. Risk is tempered by context: this is an early-stage developer tool identified only at commit level, EPSS is 0.16% (4th percentile), and no public exploit or KEV entry was identified at time of analysis.
Authentication bypass in the Salon Booking System WordPress plugin before 10.31.9 allows unauthenticated attackers to compute valid booking-API tokens for staff or administrator accounts, gaining access to the booking API as those users. The tokens are generated from a hardcoded value and the one-second issuance timestamp instead of a secure random source, so an attacker who can constrain that timestamp can forge a token. Publicly available exploit code exists, but EPSS is only 0.14% and the issue is not in CISA KEV, consistent with the high complexity (AC:H) of bounding the issuance window; the vendor has released version 10.31.9 to fix it.
OS command injection in ZoneMinder allows an authenticated user holding monitor-create or monitor-edit permission to execute arbitrary commands as the web server user by saving a Local-type monitor whose Device Path field contains shell metacharacters. The malicious stored Device value is later interpolated into shell commands in both Perl (qx()/backticks via zmdc.pl control paths and zmpkg.pl start/restart) and PHP (zmc daemon control helpers that relied on bypassable escapeshellcmd) when the monitor control or startup path runs. The issue is fixed in 1.39.2, 1.38.2, and 1.36.40, which reject any Device value not matching a strict /dev/ path pattern; no public exploit code has been identified at time of analysis, and exploitation is not confirmed actively exploited (KEV).
Privilege escalation in the ELADMIN (eladmin-mp) role management module through version 2.7 lets an authenticated non-admin user whose role has been delegated the `roles:edit` permission rewrite the menu set attached to its own role by calling PUT /api/roles/menu, because the endpoint only compares the target role's level with the caller's minimum level and never verifies that the caller is not editing itself or that the submitted menu ids are legitimate. No user interaction is needed, and the assessed CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8) reflects high confidentiality and integrity impact on the application's role and menu authorization model, since the attacker can expand its own access by granting arbitrary menu permissions. The sole prerequisite is possession of the delegated `roles:edit` permission, which is a genuine but limited barrier; no public exploit code or confirmed active exploitation was identified at the time of analysis.
Cross-site request forgery in the aThemeArt Theme Helper WordPress plugin (all versions up to and including 1.0.8) allows a remote attacker with no credentials of their own (CVSS:3.1/AV:N/AC:L/PR:N) to induce a logged-in privileged WordPress user - typically an administrator - to submit a forged request to the site, causing state-changing plugin actions to execute with the victim's authority. The flaw is a missing CSRF token check (CWE-352); the forged action is limited to operations the plugin exposes without nonce validation, and exploitation hinges on the victim having an active authenticated session and being tricked into interacting with attacker-supplied content (UI:R). A Patchstack advisory is the only public reference, and no public exploit code or confirmed active exploitation has been identified at time of analysis. Note that the supplied CVSS 3.1 vector (8.8, C:H/I:H/A:H) is more severe than our independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:L), which reflects that impact is bounded by the victim's privilege level and by which nonce-less plugin endpoints exist.
Privilege escalation in Rdiffweb lets any authenticated user promote themselves to administrator by sending a crafted POST request to the /api/users/{username_or_id} user-management endpoint with the 'role' parameter altered to an administrative value. The flaw is a missing authorization check (CWE-862) on a state-changing API route, rated CVSS 3.1 base 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) because it requires only a valid low-privilege account and no user interaction while yielding full confidentiality, integrity and availability impact. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; exposure is greatest on instances that allow self-registration or loosely provision accounts, since any such account can be turned into full administrative control.
Unauthenticated JDBC URL injection in the AllData data-dts component through version 0.7.1 allows any remote attacker who can reach the /jobJdbcDatasource/test endpoint to force the server to open an arbitrary database connection by supplying attacker-controlled jdbcUrl and jdbcDriverClass values. By pointing that URL at an attacker-hosted MySQL server with allowLoadLocalInfile=true, an attacker can abuse MySQL's LOCAL INFILE handling to read files from the data-dts host, giving high confidentiality impact (VC:H, VI:N, VA:N per our assessment) with no authentication required (PR:N, CWE-306). No public exploit code has been identified at time of analysis and the CVE is not in CISA KEV; risk is concentrated in deployments where data-dts is network-exposed, and disclosure is limited to files readable by the data-dts process account.
Unauthenticated SQL injection in IceCMS (Thecosy IceCMS) through 4.1.5 lets any remote attacker who can reach the /WebResource/findresourcebynum endpoint read arbitrary data from the backend database by supplying a crafted 'num' path parameter. The parameter is concatenated after the SQL LIMIT clause via MyBatis-Plus QueryWrapper.last() with no parameterization, so union-based or blind injection can be used to exfiltrate table contents. The assessed impact is confidentiality-only (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N) - no data modification, denial of service, or code execution - and no authentication, user interaction, or non-default configuration is required. The issue is not listed in CISA KEV and no confirmed active exploitation has been reported, but a detailed public write-up of the injection point exists, making the flaw straightforward to reproduce against network-reachable instances.
Denial of service in mz-automation libIEC61850 prior to 1.6.2 allows an unauthenticated remote peer to exhaust CPU indefinitely by sending a malformed ACSE AARE PDU during association establishment. The bug is an out-of-bounds read (CWE-125) in parseUserInformation when a truncated long-form BER length makes BerDecoder_decodeLength return a negative position that is not validated, leading to a buffer[-1] access and a parse-reset loop; a process abort is possible only when the preceding byte lies on an inaccessible memory page, making that outcome memory-layout dependent. No public exploit code or active exploitation was identified at time of analysis, and the assessed impact is availability only (CVSS 3.1 7.5), not code execution or data disclosure.
Unauthenticated memory exhaustion in the FreeRDP server-side component (3.0.0 through 3.31.x) allows a remote attacker to drive the process toward out-of-memory failure by completing a TLS handshake and then streaming bytes that do not begin with the DER SEQUENCE tag 0x30, which causes parse_nla_mode_pdu to grow the receive buffer without bound before NLA authentication ever completes. No credentials, user interaction, or non-default feature flag are required, but the attack surface is limited to hosts running a FreeRDP-based server with TLS reachable on its listening port; the far more common client role is not affected. Impact is availability-only (no code execution, no data disclosure), and no public exploit code or confirmed active exploitation has been identified at time of analysis.
Heap out-of-bounds write in FreeRDP before 3.32.0 allows a malicious RDP server to corrupt a connecting client's memory by sending crafted RDPGFX AVC444 or AVC444v2 frames, potentially enabling code execution through heap corruption. The flaw is in general_LumaToYUV444 and general_ChromaV2ToYUV444 and triggers when an odd-height region rectangle ends exactly at the surface height, causing writes past the U/V planes. Exploitation requires the victim's client to initiate or accept an RDP session with an attacker-controlled or compromised server and negotiate the affected H.264 YUV444 codec; no public exploit identified at time of analysis, and clients limited to trusted RDP hosts face substantially lower realistic risk.
Unauthenticated attackers with network reachability to the Boa-based web management interface of a Netcore NR256CN router (firmware through 1.5.140116) can crash the device's main Boa process by sending a Basic Authorization header whose base64-decoded value contains no colon separator - for example a value that decodes to a single character - to an auth-protected CGI route such as /router/get_user_type.cgi. The outcome is a denial of service that terminates the management interface until the web server process is restarted; per the assessed vector (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) there is no confidentiality or integrity impact and no code execution, and real-world risk is bounded by whether the management interface is reachable outside the LAN. No vendor patch is identified in the available data and no public exploit code is confirmed at time of analysis, though the trigger itself is trivially crafted once the interface is reachable.
Remote unauthenticated denial of service in rust-libp2p Gossipsub affects versions prior to 0.49.5 and allows any peer that can reach a Gossipsub listener to repeatedly send novel GRAFT topic hashes. The handler unconditionally records those attacker-supplied topics in the per-peer connected_peer.topics map, so memory grows cumulatively without being bounded by subscription filters, peer scoring, or per-message size limits, eventually exhausting process memory and taking the node down. No public exploit identified at time of analysis; the issue is availability-only (CVSS 4.0 8.7 / assessed CVSS 3.1 7.5), and reachability of the Gossipsub listener is the practical prerequisite.
Missing authorization in LingGuo-Drama through commit 8a6924a allows any authenticated self-registered user to fully manage all accounts via the /admin/v1/admins API. The API trusts any valid AuthAdminJWT without verifying the caller's authority level, enabling attackers to read every account's bcrypt hash, reset the bootstrap administrator's password, raise their own authority_id, and delete accounts. This is a genuine, high-priority access-control flaw (CVSS 8.7) with no public exploit identified at time of analysis; exploitation requires only that self-registration is enabled and the service is network-accessible.
Heap out-of-bounds write in FreeRDP's Apple audio-input (audin) backends affects macOS and iOS clients running versions 3.29.0 through 3.31.x, where a malicious or compromised RDP server can send an audin Open PDU with FramesPerPacket set to 2^30 to wrap a UINT32 buffer-size calculation and corrupt the heap. The vulnerable server interaction is unauthenticated from the RDP perspective (CVSS PR:N), but exploitation depends on the victim actively initiating an RDP session in which audio-input redirection is negotiated, so there is no drive-by or server-side vector and only Apple builds using audin_mac.m or audin_ios.m are exposed. No public exploit code has been identified at time of analysis, and there is no confirmation of active exploitation (CISA KEV).
Unauthenticated attackers can export all users' chat logs from 99AI 4.3.0 and earlier by sending a POST request to the /api/chatLog/exportExcel endpoint, which lacks any authentication guard (CWE-306). The vulnerability allows remote retrieval of xlsx files containing usernames, emails, prompts, and AI answers without credentials or user interaction, and affects any network-reachable instance with no special configuration. No public exploit code has been identified at time of analysis, but the exposure is high-risk because it leaks sensitive conversation data.