2026-11-03
AshAuthentication 5.0.0-rc.4 through rc.15 can be brute-forced without limit against password sign-in, password-reset requests, magic-link requests and one-time-password flows, because a configured brute_force_strategy only attaches its preparation to the actions the strategy generates itself and never verifies that resource-defined actions carry it. Projects scaffolded with mix ash_authentication.install followed by mix ash_authentication.upgrade, or with mix ash_authentication.add_strategy.otp, end up in precisely that unprotected state, and OTP sign-in under registration_enabled? true escapes protection entirely because preparations do not run on create actions. The unauthenticated attack is a guessing campaign, not a single-shot exploit, so the practical outcome is account takeover by password or OTP guessing plus unlimited password-reset and magic-link email generation; the vendor-released fix is 5.0.0-rc.16 and no public exploit code or active exploitation has been identified at time of analysis.
Authenticated users of Label Studio can turn the export converter into a full-read SSRF primitive: importing a task whose data.image points at an internal service and then requesting an export in YOLO_WITH_IMAGES, YOLO_OBB_WITH_IMAGES or COCO_WITH_IMAGES makes the server issue an HTTP GET to the attacker-chosen URL and write the response bytes into the ZIP the same user downloads, giving back the body rather than a blind probe. The same request can additionally leak the organization owner's long-lived API token to an attacker-controlled host when the Host header is spoofed so its netloc matches the task URL (ALLOWED_HOSTS defaults to '*'), though on a stock instance that token is inert while legacy_api_tokens_enabled stays off. Affected are Label Studio before 1.23.2 and label-studio-sdk before 2.1.2; the GitHub advisory contains a step-by-step proof-of-concept reproduction, and the issue is not listed in CISA KEV, so this is a genuine but mid-tier, this-month priority rather than an emergency.
Predictable email-ownership verification tokens in Cotonti through 1.0.0 let unauthenticated remote attackers activate accounts or confirm email addresses they do not control. Because tokens are generated as md5(microtime()), an attacker who reads the server's HTTP Date header can pin the whole-second portion of the timestamp, brute-force the sub-second component offline (roughly one million candidates per targeted second), and replay any matching 32-character token to the users.register.php validate handler. Severity is rated CVSS 4.0 6.3 with AC:H reflecting the microsecond-guessing requirement that limits reliability and scale; no public exploit identified at time of analysis, and priority is this_month per vulnerability intelligence scoring.
Unauthenticated SCIM directory read in Padloc through 4.3.0 lets remote attackers retrieve provisioned user and group records - usernames, emails, names, externalIds and group memberships - from the SCIM endpoints of any organization that has directory provisioning configured, simply by supplying any non-empty bearer token. The attacker must know the target organization id, which is embedded in the SCIM request URL path, and the flaw is read-only: it exposes directory metadata but does not permit modification of directory data and is inert where SCIM provisioning is not enabled. Severity is moderate (CVSS 4.0 base 6.3; assessed CVSS 3.1 6.3, confidentiality-only) with priority 'this_month'; no public exploit code or active exploitation has been identified at time of analysis.
Request smuggling in Wasmtime's wasi-http component allows a malicious WebAssembly guest to make the host forward HTTP requests carrying multiple conflicting content-length headers, potentially causing a downstream server or intermediary that does not reject such messages to interpret request boundaries incorrectly and enabling limited integrity impact. Affected releases are before 36.0.19, 37.0.0 before 48.0.7, and 49.0.0 before 49.0.4; fixed versions are 36.0.19, 48.0.7, and 49.0.4. This is a moderate, conditionally exploitable issue rather than a top-priority emergency, and no public exploit was identified at time of analysis.
Wasmtime's wasi-http p3 (WASIp3) implementation does not pass forwarded body trailers through the embedder's WasiHttpHooks::is_forbidden_header check, so a WASIp3 guest that forwards an existing request or response body can attach trailers that escape embedder-customized forbidden-header restrictions. Versions 46.0.0 through 48.0.6 and 49.0.0 through 49.0.3 of the rust/wasmtime-wasi-http crate are affected; the issue is network-reachable and unauthenticated per the CVSS v4.0 vector (6.3), but impact is limited to integrity of trailer filtering with no confidentiality or availability effect, and it only matters to embedders that customized the hook beyond DEFAULT_FORBIDDEN_HEADERS. There is no CISA KEV entry and no public exploit identified at time of analysis, and the vendor advisory states there is no known attack this enables even though it can undermine a property the embedder intended to enforce.
Parse Server deployments backed by MongoDB can have stored field values corrupted by a write that uses a dot notation key with a null value beneath a field that is not an object or array, such as a Pointer, Number, String, Date or Boolean field, or an internal field like createdAt or the ACL. The flaw is an input-validation gap (CWE-20): the same key with a non-null value was already rejected, but the null case bypassed field type validation and MongoDB then wrote a sub-document beneath the scalar field, which can make reads return a sub-document instead of the expected value, render an object entirely unreadable when an internal date field is hit, or break later atomic operations on a number field. The CVSS 4.0 score is 6.3 and the independently assessed CVSS 3.1 vector is AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L: an unauthenticated remote caller can trigger it where class-level permissions or ACLs permit public writes, otherwise the attacker must already hold write access to the affected object, and PostgreSQL deployments are not affected because they reject such writes. No public exploit code and no confirmed active exploitation were identified at time of analysis (not in CISA KEV), and vendor patches are released in 8.6.111 and 9.10.6-alpha.3.
Reflected cross-site scripting (CWE-79) in the authentication endpoint of WSO2 API Manager, WSO2 Identity Server and WSO2 API Control Plane lets an unauthenticated remote attacker inject JavaScript that executes in a victim's browser when the victim follows an attacker-crafted request or link (CVSS 3.1 base 6.1, AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N). Successful exploitation requires user interaction and social engineering, and the vendor states that session-related sensitive cookies carry the httpOnly flag, so session hijacking and cookie theft are not achievable; realistic outcomes are browser redirection to attacker-controlled sites, modification of page content shown to the user, and exfiltration of non-httpOnly browser-accessible data. No public exploit code has been identified at time of analysis, and the issue is not listed as actively exploited; priority is 'this_month' rather than immediate.
Path traversal in the zt-zip Java library's Zips fluent unpack API lets a malicious archive entry such as '../escape/poc.txt' (or a trailing-slash directory entry like '../escape/') be written outside the configured destination directory, affecting versions 1.17 and earlier and covering both the normal copy branch and the ZipEntryTransformer branch. Only applications that extract untrusted archives through Zips.get(zip).unpack().destination(dir).process() are exposed; code that uses ZipUtil.unpack(...) is unaffected because that path already performs a destination-boundary check. Rated 6.1 Medium (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:L) with integrity impact only and no direct network trigger, it requires the victim application to process an attacker-supplied archive; a public PoC reference exists in the upstream advisory, and no active exploitation has been confirmed.
Path traversal in the datadir plugin of ruTorrent before 5.3.20 lets an authenticated user escape the configured topDirectory jail and have the web server create directories and move torrent data to locations outside it. The root cause is that correctDirectory() compares the submitted datadir as written and does not resolve symbolic links, while the downstream mkdir/rename/copy operations do follow them; an attacker who can place a symlink under their own top directory and then submit a datadir path through it can redirect torrent data to any path writable by the web server or rtorrent, such as the web root. Exploitation requires a valid ruTorrent account with datadir plugin access and the ability to create that symlink; no public exploit code was identified at time of analysis, and the vendor fix is in 5.3.20.
Client-side use-after-free in FreeRDP's urbdrc USB redirection channel lets a malicious RDP server crash a connecting client that runs with /usb enabled while a matching local USB device is being announced. FindChannelById returns a raw channel pointer without taking a reference, and the control-channel CLOSE_REQUEST path frees that channel without holding the device manager's loading_lock, so the libusb announcement thread can read channel->Write from freed memory. Triggering requires the victim to initiate the connection with USB redirection active and to win a narrow timing window (AC:H/AT:P); a PoC harness shipped with the vendor advisory demonstrates the use-after-free under AddressSanitizer, but it is not an end-to-end RDP reproduction and is not verified as working exploit code, and no active exploitation has been reported.
Information disclosure in MongoDB Database Tools versions 3.1.4 through before 100.20.1 allows an authenticated user who can modify GridFS file metadata to set the stored filename to '-' and cause a later authorized mongofiles get_id retrieval without --local to write the file contents to standard output instead of a local file. The attacker only gains access to content they cannot read directly if a higher-privileged operator performs that retrieval and the captured standard output is readable by the attacker, making exploitation highly conditional; no public exploit was identified at time of analysis.
Denial of service in the Eclipse Vert.x Redis client (io.vertx:vertx-redis-client) 4.0.0 through 4.5.35 and 5.0.0 through 5.2.2 lets a malicious, compromised or man-in-the-middle Redis server exhaust the client's heap and crash the JVM. Two triggers are documented: a server that streams bytes on an EOL-terminated line (such as a simple string) without ever sending the terminating CRLF, which grows the read buffer without bounds because no configurable line limit exists, and a crafted RESP bulk string with a missing or corrupt CRLF trailer (for example `$3\r\nfooXX`) that drives the parser into an infinite loop, re-parsing the same buffer and re-emitting the same response to the consumer until memory is exhausted. The flaw is remotely reachable without authentication (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9) and affects only availability - confidentiality and integrity are not impacted - with the significant precondition that the client must be talking to an attacker-controlled or compromised endpoint; a public proof-of-concept reference exists, but it is not verified as working exploit code, and there is no CISA KEV confirmation of active exploitation. Fixed versions are 4.5.36 on the 4.x branch and 5.2.3 on the 5.x branch.
µD3TN daemon crashes and denial of service can result from a use-after-free in the Bundle Protocol version 6 (BPv6) fragmenter cleanup path. The flaw is reachable by remote, unauthenticated attackers per the CVSS vector, but triggering it requires the node to be processing BPv6 bundles and a memory allocation to fail during cleanup, so reliable exploitation depends on memory pressure or resource constraints. No public exploit code has been identified at the time of analysis and active exploitation has not been confirmed; the CVSS 5.9 score reflects availability-only impact with high attack complexity.
Denial of service in µD3TN allows an unauthenticated, remote sender of BPv6 (Bundle Protocol version 6) traffic to crash the bundle node by driving the fragmenter's block-duplication code path into a double free, but only if a heap memory allocation fails at that exact point (CVSS 5.9, CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, availability-only). Because that allocation-failure precondition is not attacker-controlled, practical exploitation generally requires first inducing memory pressure or exhaustion on the target node, which is why the vector carries AC:H. No public exploit code and no CISA KEV entry were identified at time of analysis, and the vuln.today priority is this-month remediation rather than emergency response.
WP Fastest Cache, a WordPress caching plugin, writes the full response of Core's wp-activate.php to a publicly readable cache file in versions up to and including 1.5.3, ignoring that endpoint's no-store/no-cache headers, its wp-activate-* cookie, and the WP_INSTALLING state. Because WordPress prints the new account's plaintext username and twelve-character password on that activation screen, unauthenticated attackers who can request the cached file can read the credentials of the most recently activated Multisite registrant. The exposure is heavily gated: the site must be a Multisite subdirectory installation with both public user and site registration enabled, and a real registrant must have just followed their activation link; the vulnerability is not known to be actively exploited (no CISA KEV entry) and no public exploit code was identified at time of analysis.
A divide-by-zero in NVIDIA nvJPEG (CWE-369) lets an attacker crash applications that decode a crafted JPEG image through the library, producing a denial of service with no code execution or data exposure. The CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R, A:H) requires the malformed image to reach a locally running nvJPEG consumer and a user or application to actively process it, so exposure is limited to environments that feed untrusted images into nvJPEG-based decoding such as image services and ML preprocessing pipelines. No CISA KEV entry, no confirmed public exploit, and no patch version are present in the supplied intelligence; the NVIDIA product-security advisory for 2026 (5910) is the root reference, and this is a moderate-severity availability issue rather than a top-priority emergency.
Opening and traversing a crafted HDF5 file can crash the application because H5HL_unprotect() in HDF5 through 2.2.0 may pass a NULL local-heap pointer to H5AC_unpin_entry(). The bug is a CWE-476 NULL pointer dereference: if the metadata cache destroys a corrupted local heap entry and H5HL__prfx_dest() clears heap->prfx or heap->dblk, the final unprotect has nothing to unpin, causing an assertion failure in debug builds and a crash in release builds. Impact is limited to local denial of service with user interaction and no confidentiality or integrity loss; the supplied CVSS 4.0 vector has E:P (proof-of-concept maturity), but no CISA KEV listing or confirmed working exploit code was provided.
Open redirect in the TYPO3 'mail' extension's click tracking middleware allows an unauthenticated remote attacker to craft a tracking link on a trusted TYPO3 site that forwards victims to an arbitrary external destination, turning the site's own domain into a phishing lure. It is rated CVSS 5.3 (medium) by the vendor and CVSS 4.0 5.3 by the reporting source, with the assessed vector CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:N/I:L/A:N - the practical impact is limited to integrity of the redirected-to context, so risk is social engineering rather than direct compromise. No public exploit code or PoC is referenced in the available intelligence and the issue is not in CISA KEV; the vendor priority label places it in the this-month remediation window.
Saving the backend module configuration of the third-party TYPO3 extension "mail" writes the submitted settings into page TSconfig without restricting them to the module's own configuration keys, allowing arbitrary page TSconfig injection. The flaw affects installations running the extension (CPE cpe:2.3:a:typo3:extension_"mail" with no version bound) and is reachable by a backend user who holds a valid account and has been granted access to the mail module - no victim interaction is required and attack complexity is low, but permissions are required, so it is not unauthenticated. Impact is integrity-only and low (assessed CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N); no public exploit code has been identified at time of analysis, no EPSS score or CISA KEV entry was supplied, and the vuln.today priority decision is this_month rather than an emergency.
The TYPO3 extension "mail" (EXT:mail) performs server-side fetches of content referenced by an "external URL" mail - the message body, its stylesheets and its embedded images - without validating the destination host, allowing server-side request forgery against internal network services. Exploitation requires a valid TYPO3 backend account that holds access to the mail module, so the attacker is an authenticated operator/insider rather than an anonymous outsider; no user interaction is needed and the behaviour is the extension's default. Impact is limited to low-confidentiality disclosure of what internal hosts return, with no integrity or availability effect, and an independent assessment rates the issue moderate with a this-month priority; no public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV.
Error messages returned by the Exchange RPC in Octo STS 0.11.1 and earlier disclose the contents of trust policies to callers whose OIDC token does not satisfy them. Remote, unauthenticated callers who hold any validly signed OIDC token from an accepted issuer (for example a GitHub Actions token from a repository they own) and who know or guess a target owner/repo plus identity name can read the policy's issuer, subject and audience patterns, claim_pattern regexes, and app pin details - information that frequently names internal repositories, branches, environments or cloud account identifiers, even when the policy lives in a private repository. The flaw is confidentiality-only: no token minting or trust-policy bypass is possible; the vendor issued a fix in v0.11.2 (commit 88c6432), and no public exploit was identified at time of analysis.
Axxon One deployments before version 3.2.0 on Windows and Linux expose their full user and role inventory to any authenticated low-privilege account: the security configuration API's user configuration request returns the complete lists of users and roles regardless of the caller's permissions. Because the flaw only requires valid credentials for an ordinary account and no user interaction, it lowers the barrier to privilege mapping and follow-on targeting, though it grants no modification or disruption capability. There is no public exploit code or confirmed active exploitation, and the available signals rate this as a low-urgency, non-emergency information disclosure to be scheduled for this month's patch cycle; upgrading to 3.2.0 removes the exposure.
Incorrect authorization in the Health Monitoring service of AxxonSoft AxxonNet on Linux (versions before 3.28.0) lets a remote attacker who already holds a shared report token - a credential intended only for read-only report access - create, modify, or delete monitoring alerts through the monitoring API. The flaw is a scope-enforcement failure rather than an authentication bypass in the strict sense: a valid low-privilege token is a hard prerequisite (PR:L, AV:N), and the resulting impact is limited to alert integrity and availability, with no confidentiality loss and no path to code execution. Severity is medium (CVSS 4.0 base 5.3; independently assessed CVSS 3.1 5.3, S:U/C:N/I:L/A:L); there is no CISA KEV listing and no public exploit identified at time of analysis, so the practical risk is suppression or forgery of health alerts by someone who already has report-level access.
Authorization bypass in NetBox (2.9.0 up to but not including 4.7.4) lets authenticated users who hold a bulk add-component permission such as dcim.add_interface or dcim.add_modulebay act on parent devices and virtual machines that their ObjectPermission constraints should hide from them. By submitting arbitrary primary keys in the 'pk' list, or '_all' together with a GET filter, the attacker can view out-of-scope device details and create components on those parents; the flaw is in BulkComponentCreateView, which failed to apply the 'view' permission restriction to the parent queryset. Impact is limited to confidentiality and integrity at low severity (CVSS 5.3 / assessed CVSS:3.1 5.3, PR:L, no availability impact), it requires a valid account and the add-component permission, and it matters chiefly in multi-tenant or role-separated deployments using constrained ObjectPermissions; no public exploit code was identified at time of analysis and the issue is not in CISA KEV, with a vendor fix released in 4.7.4.
Stored cross-site scripting in buku's optional bukuserver web component (versions 5.0 through 5.1.1) lets an unauthenticated remote attacker plant a bookmark URL that executes JavaScript in the browser of any user who later opens the bookmark list page. Because the injected script runs same-origin with the bukuserver UI, it can issue API requests carrying the viewer's credentials, but the realized damage is bounded to those same-origin actions and requires a separate victim to load the affected page (passive user interaction). No CISA KEV entry and no public exploit identified at time of analysis; this is a genuine but moderate-priority web vulnerability rather than a high-urgency emergency.
Missing authorization in the ClickCease Click Fraud Protection WordPress plugin, versions through 3.3.0, allows remote unauthenticated attackers to reach a plugin feature that lacks an access-control/capability check, resulting in a bounded integrity impact with no confidentiality loss and no availability impact. The CVSS 3.1 base score is 5.3 (Medium) with vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N, so no privileges and no user interaction are required, but the scope of what an attacker can change is limited (I:L). No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV; the specific endpoint or action missing the check is not described in the available sources.
AnyWhere Elementor, a WordPress plugin by WPVibes, ships with a missing authorization check (CWE-862) in versions up to and including 1.3.0, letting unauthenticated remote requests reach functionality that should have been capability-gated. Per the CVSS vector (PR:N/UI:N) no credentials or user interaction are needed, but the exposure is limited to partial confidentiality loss (C:L) with no integrity or availability impact, giving a moderate CVSS 5.3. No public exploit code or active exploitation is confirmed, and EPSS/KEV data were not provided; the trigger endpoint is not described in available sources, so real-world urgency is low-to-moderate rather than immediate.
Missing authorization in the weDevs Dokan Lite WordPress plugin (Dokan through 5.3.2) lets unauthenticated remote attackers reach functionality that should be access-controlled and read restricted data from the site. Rated CVSS 5.3 with confidentiality-only, low-magnitude impact (C:L/I:N/A:N), it needs no credentials and no user interaction against any site running an affected version. No public exploit was identified at time of analysis and there is no confirmed active exploitation; the priority label for this issue is 'this_month'.
Missing authorization in the Dokan Lite WordPress plugin through 5.3.2 permits unauthenticated network attackers to access limited information guarded by incorrectly configured access controls, with low confidentiality impact and no integrity or availability effect. No public exploit is identified at time of analysis, and active exploitation is not confirmed in the supplied data.
Missing authorization in WPMU DEV Forminator through 1.58.3 allows remote unauthenticated attackers to make limited integrity-impacting changes on WordPress sites running the plugin, per the CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N with C:N/I:L/A:N. No public exploit was identified at time of analysis, and the issue is assessed as a moderate-severity, low-priority concern rather than an emergency; the specific endpoint or feature that triggers the flaw is not described in the available sources.
Missing authorization checks in the WC Lovers WCFM Membership WordPress plugin, in all versions up to and including 2.12.0, allow unauthenticated remote attackers to reach plugin functionality that should be gated by an access-control decision, with the official vector (CVSS 3.1 5.3, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N) describing only limited integrity impact and no confidentiality or availability effect. The flaw is classified CWE-862 (Missing Authorization), and the specific feature, endpoint or action that lacks the check is not described in the available sources. No CISA KEV entry and no public exploit code were identified at time of analysis, and the vulnerability is rated 'this_month' in the priority decision signal rather than act-now urgency.
Unauthenticated remote attackers can bypass intended access-control restrictions in the WordPress plugin Uncanny Automator through version 7.7.1, because a function or endpoint lacks a proper authorization check (CWE-862). The CVSS 3.1 score is 5.3 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N), so the worst confirmed outcome is limited integrity impact with no confidentiality or availability effect; the specific endpoint, feature, or configuration that exposes the missing check is not described in the available sources. No public exploit code and no confirmed active exploitation were identified at time of analysis, and vendor advisory details are available through Patchstack.
Unauthenticated information disclosure affects the WebberZone Better Search WordPress plugin through version 4.5.2, where a missing authorization check (CWE-862) lets network attackers reach functionality that should be access-controlled, exposing limited data (CVSS 5.3, C:L/I:N/A:N). Per the CVSS vector (PR:N/UI:N), no credentials or user interaction are required, but the impact is confined to partial confidentiality loss with no modification or denial of service. No public exploit code or CISA KEV entry was provided; the trigger endpoint is not described in the available sources, and the issue should be scheduled for patching rather than treated as an emergency.
Stored cross-site scripting in TeXlyre 0.11.0 through 0.13.4 lets an attacker run arbitrary JavaScript in the TeXlyre origin by supplying a malicious LSP or typesetter recipe whose free-form 'icon' field carries an HTML event handler such as <img onerror=...>; the payload is stored in the user's settings and re-executes each time the tool-settings card is rendered. Exploitation requires the victim to actively import the recipe via Settings → Import (file, URL, or pasted JSON), so the attack depends on social engineering around TeXlyre's recipe-sharing feature rather than unattended remote triggering. A public PoC reference exists in the vendor advisory; it is not verified as working exploit code, the issue is not listed in CISA KEV, and success yields read/exfiltration of IndexedDB-stored project documents plus access to in-memory decrypted Git backup tokens.
Missing authorization in Dromara domain-admin before 1.6.79 allows authenticated users to read member metadata from groups they do not belong to by calling POST /api/getGroupUserList with other group_id values. Attackers can enumerate sequential group IDs to disclose member usernames, leader and edit-permission flags, and owner usernames; exploitation requires a valid low-privileged account. No public exploit was identified at time of analysis, and the vendor has released version 1.6.79 with a group-membership permission check.
DbGate before 7.3.3 does not enforce LOGIN_PERMISSIONS connection restrictions on the /connections/test and /connections/save endpoints, so an authenticated user who is supposed to be limited to specific database connections can instead submit arbitrary connection definitions. That lets the user probe internal database hosts through the test endpoint and overwrite stored connection definitions through the save endpoint, both with limited (Low) confidentiality and integrity impact. Exploitation requires a valid low-privilege account in a multi-user deployment that actually enforces per-connection restrictions; no public exploit code has been identified at time of analysis, and the issue is rated medium severity (CVSS 5.3) with a moderate rather than urgent priority.
Cross-site scripting bypass in svg-sanitizer (Composer package enshrined/svg-sanitize) 1.0.0 and earlier lets an attacker who can supply or upload SVG content place a javascript: URL inside an animateTransform values attribute, which survives sanitization and overwrites an anchor's href, executing arbitrary JavaScript when a victim clicks the link. The bypass only fires in Apple Safari, which uniquely allows animateTransform to target href, and requires the victim to click the affected link (UI:R), so this is a genuine but moderate-risk stored-XSS sanitizer flaw rather than an emergency; the vendor demo tool accepted the published payload. No confirmed active exploitation or KEV listing is reported, and the upstream security advisory documents a public proof-of-concept payload; upgrading to 1.1.0 removes the bypass.
SVG Sanitizer 0.5.0 through 1.0.0 fails to strip remote URLs expressed with CSS escape sequences inside url() in SVG presentation attributes, so a sanitized SVG can still cause a browser to make an outbound request when rendered. The advisory shows that fill="url(//evil.example/x)" is removed while fill="url(\2f\2f evil.example/x)" is not, which can enable data exfiltration depending on how the application uses the SVG. This is a medium-severity issue (CVSS 4.0 base 5.3) with a this-month remediation priority; CISA KEV status is not indicated in the supplied data, and a public PoC reference exists in GHSA-3vh3-jf65-656w but is not verified as working exploit code.
Frappe HRMS before 15.61.0 allows any authenticated employee to read other employees' expense advance records by querying the Expense Claim Advances API, which fails to enforce ownership-based authorization (CWE-639). The exposure is limited to read access of sensitive financial data belonging to coworkers; there is no integrity or availability impact and an attacker must already hold valid employee credentials on the instance. A public advisory exists, no public exploit code has been identified at time of analysis, and this is tracked as a moderate-severity information-disclosure issue rather than an emergency.
Froxlor versions through 2.3.14 allow an authenticated customer to create MySQL databases through the Mysqls.add API endpoint even when the administrator has explicitly hidden or disabled the MySQL feature via panel.customer_hide_options, because add() omits the authorization check that get(), update(), and delete() enforce. The result is a policy violation rather than a breach: the customer provisions unauthorized databases only within their own existing quota, with no code execution or access to other tenants' data. This is a low-to-moderate real-world risk and should be treated as a policy/hardening fix rather than an urgent emergency; no public exploit code is confirmed in the available data, and exploitation requires both a valid customer account and the MySQL feature already being hidden.
Froxlor 2.3.0 through 2.3.14 lets an authenticated customer who holds a valid API key overwrite the Let's Encrypt-managed certificate and private key of a domain they own, because the Certificates.add and Certificates.update API commands never check the letsencrypt flag that the UI and read paths enforce. The attacker-supplied key pair is stored in domain_ssl_settings and pushed into the webserver configuration by a REBUILD_VHOST task, degrading or breaking HTTPS for that domain's visitors until the next ACME renewal and desynchronizing the panel from acme.sh; the original LE private key stays unreadable, so the exposure is an integrity/availability gap on the write path. Exploitation is bounded to the attacker's own domains and requires API access to be enabled for the customer account; a proof-of-concept with reproduction steps is documented in the published advisory, and no CISA KEV entry or EPSS score accompanies this CVE.
AzuraCast's station waveform endpoints (GET and POST /api/station/{station_id}/waveform/{media_id}) are missing the Permissions middleware that every sibling station-scoped media route carries, so any authenticated user - even one with no station assignment at all - can read another station's cached waveform JSON and overwrite it with arbitrary content. Successful abuse gives limited cross-station data disclosure and limited tampering with the Visual Cue Editor waveform data, not access to media files, credentials, or arbitrary filesystem paths (CVSS 3.1: AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N; CVSS 4.0 base 5.3). Authentication of the lowest privilege tier is required and the attacker must reach the API with a target station_id and media_id; VulnCheck and the upstream advisory provide a PoC reference that boots the real application and introspects its compiled route table to prove the missing middleware - it is not verified as working end-to-end exploit code, and there is no KEV listing or active-exploitation reporting.
SurrealDB 3.1.0 through 3.2.x mishandles port-specific network deny rules, so an authenticated user who can call the http::* functions can reach an internal service that a --deny-net HOST:PORT or IP:PORT rule was meant to block simply by naming the same target through a different alias (a hostname that resolves to the denied IP, or the bare IP of a denied hostname). The advisory demonstrates this against the v3.2.0 release binary with published reproduction steps, so a public proof-of-concept reference exists; there is no CISA KEV entry indicating active exploitation. Scope is bounded: it is an egress-policy bypass that only matters to deployments relying on port-bearing deny rules, and bare-IP deny rules are unaffected; it is fixed in 3.3.0.
Incorrect authorization in SurrealDB 3.1.0 through 3.2.x lets an authenticated record user recover restricted field values by inference: the default streaming execution planner selects FULLTEXT, compound B-tree and HNSW indexes built on fields whose field-level SELECT permission is not FULL, then drops the index-covered predicate instead of re-evaluating it against the permission-reduced document. Affected are deployments that combine restrictive field-level SELECT permissions with indexes on those fields; direct SELECT output continues to hide the values, but result-set membership and ordering act as a confirmation or nearest-neighbour oracle, so the impact is low-severity, confidentiality-only disclosure (CVSS 4.0 5.3 / CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N, CWE-863/CWE-200). A public PoC reference exists (a reproduction script with recorded results in the GitHub advisory); it is not verified as working exploit code, and there is no CISA KEV listing.
FreeRDP clients up to and including 3.32.1 can be terminated by a malicious or compromised RDP server that sends a crafted ALPHA WIRETOSURFACE_2 graphics-pipeline command with zero width and zero height. The session crash is client-side and requires the victim to connect to the attacker's server with RDPGFX active (AUTODETECT enables it), so exploitation depends on a user-initiated connection rather than an exposed listening service. Confirmed termination was observed on builds compiled with verbose WINPR assertions, where an element-size assertion aborts the process; on builds without that assertion the advisory describes a following division by zero as a plausible but not executed termination path. No CISA KEV listing exists; the advisory supplies a handler-level reproducer and documents a preserved live server test, but this is not verified general-purpose exploit code.
Denial of service in FreeRDP clients at version 3.32.1 and earlier lets a malicious or compromised RDP server terminate the connecting client by sending a three-byte zero-output ZGFX payload (E0 20 00) on the RDPGFX dynamic channel after session activation. The decompressor returns success while leaving its output pointer null and its size zero, and rdpgfx_on_data_received - which rejects only negative decoder status - forwards that null pointer into Stream_StaticConstInit, whose WINPR_ASSERT(buffer) aborts builds compiled with verbose WinPR assertions, the upstream CMake default. A component-level reproduction and a documented live xfreerdp test (client exit 134) are public; only assertion-enabled builds are affected, the verified impact is limited to client availability with no memory corruption, disclosure or code execution, and no CISA KEV listing or confirmed active exploitation is reported (priority label: this_month).
FreeRDP clients up to and including 3.32.1 can be driven into excessive memory allocation by a malicious RDP server when serial device redirection is enabled, because the serial channel fails to cap the server-supplied OutputBufferLength carried in an IRP_MJ_DEVICE_CONTROL request before allocating and echoing it back. Only availability is affected: the vendor measured roughly 4.01 GiB peak RSS and about 3.8 seconds of handler time from a single IOCTL_USBPRINT_GET_1284_ID request, with no confidentiality or integrity impact observed. Exploitation requires the victim to connect out to an attacker-controlled server and to have serial redirection configured with a redirected device successfully opened; no public exploit is identified beyond the reproduction harness published in the vendor advisory, and there is no CISA KEV confirmation of active exploitation.
Drive redirection in FreeRDP 3.32.1 and earlier can be silently disabled by a malicious RDP server: a single truncated IRP_MJ_CREATE device I/O request terminates the drive worker while leaving its error state at CHANNEL_RC_OK, so the RDPDR channel stays up and every subsequent server request is queued in IrpQueue with no consumer until memory is exhausted or the session ends. Only clients that initiate a connection to an attacker-controlled or compromised RDP server with drive redirection enabled (/drive or drivestoredirect) under the default asynchronous RDPDR dispatch are affected, and the impact is availability loss confined to that session, with no confidentiality or integrity impact (assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L; upstream rates it 5.3). There is no CISA KEV listing and no reported in-the-wild exploitation; a public proof-of-concept verification harness accompanies the vendor advisory, and the issue is fixed in 3.32.2.
FreeRDP clients up to and including 3.32.1 can be crashed by a malicious or compromised RD Gateway that sends a PKT_TYPE_EXTENDED_AUTH_MSG (type 0x0003) immediately after the HTTP/WebSocket upgrade, before tunnel authentication completes. In the default configuration (GatewayHttpExtAuthSspiNtlm=FALSE) the HTTP authentication context is freed before tunnel packets are processed, so rdg_process_packet dispatches the extended-auth packet with rdg->auth NULL and a zero-length blob reaches credssp_auth_is_complete(NULL), producing a null-pointer dereference; the advisory documents an abort (exit 134) on an assertions-enabled build and a null-pointer read crash (exit 139) on an assertions-off build, with no memory-corruption or data-access effect demonstrated. The attacker does not reach the client directly: the victim must initiate a connection to the hostile gateway (CVSS 4.0 AV:N/PR:N/UI:P, our assessed CVSS 3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L, availability-only impact). A public proof-of-concept reproduction is published in the GitHub security advisory GHSA-8rjm-m7xg-mg6m and has been independently re-verified to crash affected clients; the issue is not in CISA KEV and no in-the-wild exploitation is reported, and the vulnerability is fixed in 3.32.2.