Remote unauthenticated exploitation of MikroTik RouterOS's Bandwidth Test (btest) service allows two distinct attacks: kernel memory disclosure and kernel crash/restart. The btest server accepts a 'related' secondary UDP connection before the primary TCP control session completes authentication, permitting a pre-auth attacker to drive the btest data path. With random-data=false, the kernel transmits uninitialized packet buffer contents to the attacker; a separate unchecked inverted packet-size interval triggers unsigned integer underflow producing anomalously large fragmented output that crashes the RouterOS kernel. CERT-PL reported this vulnerability and a CERT-PL advisory titled 'actively exploited' indicates in-the-wild use, though CISA KEV confirmation is absent from available data; a public exploit and binary reverse-engineering write-up are available.
RegistrationMagic WordPress plugin before version 6.0.9.9 omits audience validation on Facebook OAuth access tokens during social login, creating two exploitable paths: an attacker who obtains any valid Facebook token belonging to a site user - regardless of which Facebook application issued it - can authenticate to the WordPress site as that user, and a separate path allows account creation even when site registration is explicitly disabled. Publicly available exploit code has been published by WPScan, and the high CIA impact score reflects that full account compromise is achievable on affected installations with the Facebook login feature enabled.
Unauthenticated file read in MikroTik RouterOS WebFig exposes root-owned configuration files - including credential stores - to any network attacker who can reach the management interface. The vulnerability chains an uninitialized principal pointer (CWE-824) in /jsproxy session allocation with an encrypted URI path traversal, allowing pre-authentication escalation of file-read rights followed by namespace escape. Fixed versions 6.49.21 (Long-term), 7.23.4 (Long-term), and 7.24.2 (Stable) are available; a public exploit writeup exists, and CERT-PL's September 2026 reporting references active exploitation of this class of MikroTik vulnerabilities.
Privilege escalation in Pterodactyl Panel before 1.14.1 allows authenticated subusers holding only the schedule.update permission to execute arbitrary game-server console commands, alter server power state, and trigger backup creation without the corresponding action-specific authorization. The root cause is explicitly documented in the original source code - StoreTaskRequest.php stated 'There are no task specific permissions' - meaning any subuser authorized to modify schedules could embed any privileged action into a task and immediately fire it via the execute endpoint. A public exploit write-up is available, and vendor-released patch v1.14.1 fully remediates the issue.
Host header injection in the Grav API plugin's forgot-password endpoint allows unauthenticated remote attackers to redirect password-reset tokens to attacker-controlled domains, enabling full account takeover including super-admin accounts. The plugin blindly incorporates the HTTP Host header when constructing reset links dispatched to victims' inboxes; an attacker who spoofs this header and induces the target to click the resulting email link captures the token and seizes the account. All Grav API plugin deployments running versions prior to 1.0.20 are affected; no public exploit code or CISA KEV listing has been identified at time of analysis, though the attack is straightforward to execute.
SQL injection in the Music Store WordPress plugin (versions 1.0.245 through before 1.4.5) enables unauthenticated remote attackers to extract the entire WordPress database via crafted HTTP requests. The CVSS Scope:Changed vector reflects that exploitation can read data beyond the plugin's own tables - including WordPress user credentials, email addresses, and site configuration stored by other plugins. A publicly available exploit is documented on WPScan, though no confirmed active exploitation (CISA KEV) has been recorded.
Stored cross-site scripting in the JCH Optimize WordPress plugin before 6.0.1 allows any authenticated user with Subscriber-level access to import arbitrary plugin settings via an unprotected AJAX endpoint, injecting persistent JavaScript that executes in the browsers of site visitors and administrators. The missing capability check means that low-privilege accounts bypass the intended authorization boundary, enabling stored XSS delivery without administrative permissions. A publicly available proof-of-concept from WPScan exists, and the vendor has released a fix in version 6.0.1.
Stored cross-site scripting in the HT Menu WordPress plugin before 1.2.7 allows any authenticated subscriber-level user to inject arbitrary JavaScript into navigation menu-item settings, which then executes in the browser of every site visitor - including administrators - who views the affected menu. The flaw combines two missing controls: no capability or ownership check on the settings-save endpoint, and no output escaping on render. A public exploit is available via WPScan, and vendor-released patch 1.2.7 is available. No public KEV listing; EPSS is low at 0.15%, consistent with targeted rather than mass exploitation.
Authentication bypass in N-able N-central before version 2026.3 HF 3 permits low-privileged authenticated users to access internal-only APIs without proper authorization checks, achieving effective privilege escalation within the platform. N-central is a remote monitoring and management (RMM) platform used extensively by managed service providers (MSPs) to control customer endpoints, meaning unauthorized API access could cascade to managed devices across multiple customer environments. No public exploit has been identified at time of analysis, but a vendor patch has been released as HF 3.
JetFormBuilder - Dynamic Blocks Form Builder for WordPress before version 3.6.5.2 exposes sensitive site data to unauthenticated remote attackers due to missing authorization checks during page rendering. By submitting crafted requests that reference internal WordPress data sources, attackers can read arbitrary user properties including password hashes, private and draft post content, term metadata, and secrets stored by the plugin in post metadata fields. A publicly available proof-of-concept exploit exists, and the zero-privilege network attack path makes this a credible mass-scanning target for WordPress infrastructure.
Credential exposure in NetBox through 4.7.0 allows any authenticated user with only view-level permissions to retrieve plaintext Git passwords and Amazon S3 secret access keys via the REST API and GraphQL interfaces. The flaw is rooted in missing field-level redaction in the API serializer and GraphQL type layer, and represents an incomplete remediation of a previously reported issue (GitHub issue #12625). A public proof-of-concept is available, and successful exploitation grants attackers direct access to external Git repositories and S3 storage buckets configured as NetBox data source backends - extending the breach well beyond the NetBox instance itself.
Reflected Cross-Site Scripting in the IPGP Visitors Origin WordPress plugin before version 1.6 allows unauthenticated remote attackers to inject arbitrary JavaScript into victims' browsers by delivering a crafted URL that the plugin echoes back unsanitized. No server-side authentication is required from the attacker, though victim interaction (clicking or submitting a crafted request) is mandatory for payload execution. A publicly available proof-of-concept via WPScan lowers the exploitation barrier, though EPSS of 0.18% indicates limited automated scanning activity to date and no active exploitation has been confirmed by CISA KEV.
PHP Object Injection in the Welcart e-Commerce WordPress plugin (all versions ≤ 2.12.1) enables unauthenticated attackers to inject a serialized POP-chain payload as order metadata during a public checkout, then trigger deserialization through the unprotected Telecom EDY payment callback. Exploitation via a bundled TCPDF POP chain can delete arbitrary server files - including wp-config.php - and culminates in full remote code execution when the attacker re-runs the WordPress installer against an attacker-controlled database. Successful file deletion requires an administrator to print an order invoice, captured by UI:R in the CVSS vector; no public exploit or CISA KEV listing has been identified at time of analysis.
Privilege escalation in the Nokri Job Board WordPress Theme (all versions through 1.6.4) allows authenticated attackers with Subscriber-level access to perform a two-stage account takeover: they invoke the unprotected nokri_account_member_permissions function to grant employer-level permissions to any Subscriber account, and the elevated Subscriber can then update the email address of any WordPress user - including Administrators - enabling full site compromise via password reset. Reported by Wordfence, this vulnerability scores CVSS 8.8 (AV:N/AC:L/PR:L). No public exploit code or CISA KEV listing has been identified at time of analysis.
Privilege escalation in the Abandoned Cart Pro for WooCommerce WordPress plugin (all versions through 10.7.1) allows authenticated subscribers to gain full WordPress administrative access by hijacking the plugin's SMTP email routing. Missing capability checks and nonce verification on at least four AJAX endpoints - including wcap_save_connector_settings - permit any subscriber-level user to silently redirect outbound SMTP traffic through an attacker-controlled mail server. Once SMTP is redirected, the attacker intercepts auto-login recovery links sent to administrators and authenticates as admin without any further credentials. No public exploit has been identified at time of analysis, but the attack exploits a default-enabled feature, significantly lowering the bar for abuse on any standard installation.
Remote code execution in Axolotl through 0.18.0 allows an attacker who controls a Hugging Face model repository to execute arbitrary Python code on any machine running an Axolotl training job with multipack patches enabled. The root cause is a logic flaw in `_apply_multipack_patches()`: when a user has not explicitly set `trust_remote_code` in their YAML config (leaving it as Python `None`), the guard condition `self.cfg.trust_remote_code is not None` evaluates to `False`, skipping the override assignment and leaving `has_remote_code=True` from the model's own metadata claim. Downstream code in `multipack.py` then calls `AutoModelForCausalLM.from_pretrained` with `trust_remote_code=True` hardcoded, executing whatever Python the model repository supplies. No public exploit is identified at time of analysis, but the attack surface is broad for teams running automated fine-tuning pipelines that source models from HuggingFace without explicit config hardening.
Unauthenticated server-side request forgery in MindsDB through 26.1.0 allows remote attackers to coerce the platform's web crawler handler into fetching arbitrary attacker-supplied URLs. The root cause is a default-empty allowlist in CrawlerTable.list (web_handler.py lines 50-65), meaning MindsDB ships with no URL restrictions enforced, enabling direct access to internal network services and cloud instance metadata endpoints (e.g., AWS IMDSv1 at 169.254.169.254). No public exploit has been confirmed at time of analysis, but VulnCheck published a detailed advisory with precise source-code references, lowering the bar to exploitation significantly.
Privilege escalation in grav-plugin-api before 1.0.20 allows a low-privileged API manager to self-create a super-admin account by exploiting a logic gap in the InvitationsController's stripSuperFlags() method, which strips nested super flags but ignores dot-keyed equivalents such as 'api.super'. The attacker crafts an invitation payload containing the dot-keyed flag, which persists through sanitization into the new account, then self-accepts the invitation via the public acceptance endpoint - no real invitee participation required - and immediately receives a valid JWT granting full Grav site control. No public exploit or CISA KEV listing is present at time of analysis, but the attack is fully self-contained and conceptually trivial for any account already holding api.users.write permissions.
Privilege escalation in grav-plugin-api before 1.0.20 allows authenticated API users holding api.access and api.users.write permissions to overwrite the password of super-admin accounts whose elevated status is inherited through group membership rather than direct assignment. The user-management guard fails to evaluate group-inherited super status, treating those accounts as unprotected targets. An attacker who successfully exploits this gains full Grav CMS administrative control. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS 4.0 score of 8.7 reflects high impact across confidentiality and integrity.
Unvalidated BPF scratch-register array index in libpcap's user-space BPF interpreter allows a local attacker with low privileges to craft a filter program that reads or writes OS process memory beyond the intended 16-entry M[] scratch array. On 64-bit architectures the accessible range is up to 16GiB starting at the current stack frame; on 32-bit architectures the entire process address space is reachable. The Tcpdump Group has issued a fix (commit 48e8960a) that adds bounds checks before every M[] access, rejecting filters referencing register index ≥ BPF_MEMWORDS (16). No public exploit or CISA KEV listing is identified at time of analysis.
Bilibili Desktop through v1.18.0 achieves full system command execution and credential theft by combining two design-level failures: TLS certificate verification is disabled process-wide (accepting any certificate, including attacker-controlled), and remote JavaScript configuration is fetched and executed without code-signing or integrity validation. Any on-path network adversary - via rogue Wi-Fi, ARP spoofing, or a compromised gateway - can intercept these fetches, present a forged certificate, and inject arbitrary JavaScript that runs in the app's renderer context with direct access to the privileged IPC bridge, enabling OS-level command execution or session-token exfiltration. A public proof-of-concept repository exists (GitHub: LeoWSY-hashblue/bilibili-desktop-tls-disabled-rce); no vendor-released patch has been identified at time of analysis.
Out-of-bounds heap write in PCRE2 before 10.48 allows memory corruption via the DFA matching engine when a cached workspace block is reused in a recursive context without the size check that guards a freshly allocated block of the same type. Applications that pass attacker-controlled regular expressions to pcre2_dfa_match, or that configure a small heap limit via the PCRE2 API while processing recursive patterns, are exploitable. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog; however, PCRE2 10.48 ships a confirmed vendor fix alongside four other security patches in the same release.
SSRF, XXE and denial of service exposure arise in libxml2 before 2.15.4 because xmlXIncludeProcess and xmlXIncludeProcessTree fail to propagate the document's parseFlags down to the parser contexts they create for XInclude resolution. When parseFlags are dropped, protective options such as XML_PARSE_NONET stop being enforced, so an attacker-supplied document containing an external xi:include href can force outbound network fetches through the application's resource loader — enabling server-side request forgery, external entity injection, or a hang driven by an intentionally slow remote resource. Exploitation requires an application that enables XInclude and relies on XML_PARSE_NONET (typically with a custom resource loader); no public exploit code has been identified and EPSS is very low at 0.16% (6th percentile), with no CISA KEV listing.
Let me construct the JSON. Key facts: libxml2 before 2.15.4, xmlSnprintfElements in valid.c, strcat stack buffer overflow, CWE-121. CVSS 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. EPSS 0.14% (3rd percentile). Patch available from vendor; commit d1686f91. Fix versions: 2.15.4. Red Hat RHSA-2026:64463. No KEV, no POC mentioned. Note the vector AV:L PR:L — local, low privileges. That's interesting because libxml2 is used in parsing. Local vector means the attacker needs to run code that triggers xmlSnprintfElements. Actually the CVSS provided says AV:L/PR:L. Hmm, that seems odd for a library parsing untrusted XML, but I should respect the input. Wait — actually, the input CVSS vector says AV:L/AC:L/PR:L. But note: the "CRITICAL FIELD" instructions say I should not infer auth from description. The vector is provided so I can say PR:L → "authenticated"/local low-privileged. Interesting tension: the vulnerable function is a validation error-message builder. xmlSnprintfElements builds the error message listing expected elements. It's triggered when validation fails on a deeply-nested/large content model — likely reachable via parsing untrusted XML with validation enabled (xmlValidateDocument / well-formedness? Actually valid.c is used for DTD validation). So remote attacks via parsing malicious XML with validation enabled could be possible; the AV:L in the provided vector may be conservative or wrong. I should flag that in risk_assessment — note conflicting signal. I'll write assessed_cvss_vector myself. Should I keep AV:L? The instruction: "Choose PR honestly: if exploitation requires control over configuration files, admin access, or authentication, use PR:H or PR:L — never PR:N for operator/config-dependent flaws. Use AV:L when the vector is local/config-only." Hmm. The vulnerability is in a library parsing XML documents. If an application validates untrusted XML with DTD validation, the buffer overflow could be triggered remotely (AV:N, PR:N, UI:N) in the context
Let me produce the JSON. Key facts: libxml2 heap buffer overflow in xmlXPtrEvalXPtrPart due to xmlXPtrEval xpointer length saturation. CVSS 7.8 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. CWE-122. EPSS 0.13% (3rd percentile). Patch available, fixed in 2.15.4. No KEV, no POC mentioned. Note: CVSS is local vector, PR:L — so authenticated/local access needed. XPointer evaluation requires parsing untrusted XML/XPointer input. Actually the CVSS says AV:L PR:L which suggests local attacker with low privileges — but libxml2 is typically parsed remotely via XML input. There's a tension: the vector says local. I should note that in risk_assessment — conflicting signal. Product name: "libxml2" (2 words? it's one word). Fine. Prevalence: high — libxml2 is widely deployed (core library in many systems). Could argue "ubiquitous". libxml2 is in nearly every Linux distro, used by many apps. I'd say "high" or "ubiquitous". Given anchors: OpenSSL/nginx/Linux kernel = ubiquitous. libxml2 is comparably widespread as a library dependency. I'll say "ubiquitous"? Hmm. It's a core XML parsing library used by GNOME, PHP, Python lxml, many. I'd say "high" to be safe... Actually libxml2 is extremely pervasive. But prevalence is deployment footprint in production. I'll go with "high" with basis "ubiquitous XML parser library across Linux distributions and apps". Hmm, "ubiquitous" anchor is OpenSSL/nginx/kernel. libxml2 is arguably in that class. I'll choose "high" — widely deployed but often not directly network-exposed. Let me pick "high". Actually let me reconsider: libxml2 is bundled in virtually every Linux distro, used by PHP, Python, Ruby, GNOME, etc. That's arguably closer to ubiquitous. But the anchor "high" = widely-deployed enterprise software. I'll go with "high" and basis "core XML parser in most Linux distributions and many apps". Hmm, either is defensible. I'll say "high". assessed_cvss_vector: The vulnerability requires evaluating an XPointer with hostile input. Root cause: len
Heap-based buffer overflow in libxml2 before 2.15.4, reachable through the internal dictionary routine xmlDictAddQString() in dict.c, which miscalculates the size of an exponentially growing string pool and can be driven past the integer range before allocating. Per the vendor-assigned CVSS vector the attack is local with low privileges (AV:L/PR:L), so it primarily affects applications, daemons, or sandboxed services that parse attacker-influenced XML under a constrained account. A vendor patch (2.15.4, commit a4cba4b5) and a Red Hat errata exist, but there is no CISA KEV listing and no confirmed public exploit — EPSS is only 0.12% (2nd percentile), so this is a patch-hygiene item rather than a fire drill.
An integer overflow in libxml2's xmlURIEscapeStr() URI-escaping routine, present in all versions before 2.15.4, allows heap memory corruption that can lead to code execution in the context of the process using the library (CVSS 7.8, AV:L/PR:L). The issue is reachable only by a local, low-privileged actor who can drive an oversized string into libxml2's URI handling helpers, and CISA's SSVC rates it non-automatable with no known exploitation. No public exploit code or CISA KEV listing was identified; EPSS is 0.11% (1st percentile), and the fix landed upstream in the 2.15.4 release and in Red Hat errata RHSA-2026:64463.
External-login account password generation in WWBN AVideo uses PHP's non-cryptographic rand() function, producing a keyspace of only 2^31 integers, and stores resulting passwords as unsalted MD5 hashes. An attacker who obtains the AVideo password hash database can exhaustively search the entire 2-billion-entry keyspace in seconds to minutes on commodity GPU hardware, recovering plaintext credentials for all external-login accounts. No public exploit has been identified at time of analysis; the CVSS 4.0 score of 7.4 reflects the prerequisite of prior hash access.
Integer-overflow handling in libxml2's xmlIO output path lets a negative length reach application-supplied write callbacks, allowing memory corruption or denial of service in programs that serialize large XML documents. All libxml2 builds before 2.15.4 are affected; the upstream commit 90f293ba adds INT_MAX guards to xmlOutputBufferWrite and xmlOutputBufferFlush and the fix ships in 2.15.4 (also distributed via RHSA-2026:64463). CVSS is 7.3 (AV:L/PR:L), EPSS is only 0.12% (2nd percentile), there is no public exploit identified at time of analysis, and the issue is not listed in CISA KEV.
Stored cross-site scripting in the Contact Form by Supsystic WordPress plugin (all versions ≤1.10.2) allows unauthenticated attackers to inject persistent malicious scripts via a spoofed IP address header. The exploit chain is notable for its two-stage unauthenticated entry: the plugin's `updateNonce` action is excluded from the permission-check list, granting any unauthenticated caller a valid WordPress nonce; that nonce is then used to submit a contact form with a crafted `X-Forwarded-For` value, which the plugin stores unsanitized and later renders in the admin contacts list. No public exploit has been identified at time of analysis and no KEV listing exists, but the Wordfence advisory includes direct source-code references to the vulnerable code paths.
Stored Cross-Site Scripting in the iubenda All-in-one Compliance for GDPR/CCPA WordPress plugin (versions ≤3.13.4) allows unauthenticated attackers to inject persistent malicious scripts into pages via comment content processed through the AdSense regex rewrite path. The injected payload executes in any visiting user's browser, enabling session hijacking, credential theft, or malicious redirects. Exploitation is gated by a non-default parser engine configuration - sites running the newer DOM-based parser are not affected. Vendor-released patch 3.13.5 resolves the issue; no public exploit or KEV listing identified at time of analysis.
Stored Cross-Site Scripting in W3 Total Cache (WordPress plugin) versions up to and including 2.10.5 allows unauthenticated attackers to inject arbitrary JavaScript via comment content processed by the LazyLoad Background Mutator. The flaw stems from insufficient sanitization and output escaping in UserExperience_LazyLoad_Mutator.php, specifically where comment text containing background-image CSS is mutated for lazy loading. Exploitation requires two non-default conditions: the Lazy Load Images feature with 'Process background images' enabled, and the malicious comment must be approved by a moderator before the payload executes against visiting users. A vendor-released patch is available in version 2.10.6.
Stored Cross-Site Scripting in the SureForms plugin for WordPress (all versions up to and including 2.12.2) permits unauthenticated form submitters to embed persistent malicious scripts by bypassing sanitization with entity-encoded payloads in text fields. The injected payload executes in any visitor's or administrator's browser when they load an affected page, enabling session hijacking, cookie theft, or page defacement across any WordPress site running the vulnerable plugin version. Wordfence reported the issue and a fix was released in version 2.12.3.
Stored cross-site scripting in the CleanTalk Spam Protection, Honeypot, Anti-Spam WordPress plugin (all versions through 6.86) allows injection of arbitrary JavaScript via unescaped aria-label attributes rendered from comment content by the plugin's ContactsEncoder component. The unauthenticated comment submission path makes the payload deliverable without credentials, though script execution is limited to non-logged-in visitors, and sites with comment moderation enabled require an administrator to approve the comment before it reaches other users. Version 6.87 contains the confirmed fix per WordPress SVN changeset 3677388; no public exploit code or CISA KEV entry is identified at time of analysis.
Stored XSS with on-disk file write capability in the Ninja Forms WordPress plugin (versions ≤3.15.1) allows unauthenticated remote attackers to plant attacker-controlled HTML/JavaScript files anywhere in the web server's writable directory tree - including the site root - when the separately-installed Ninja Forms File Uploads add-on is active. The attack exploits a 'type' confusion flaw in Repeater child field processing: an unrecognized array key causes the submission pipeline to misroute input through the File Uploads handler, which writes raw attacker-supplied content to disk where it is subsequently served from the site's own origin. The fix is confirmed in version 3.15.2 via WordPress.org SVN changeset; no public exploit or CISA KEV listing has been identified at time of analysis.
Stored Cross-Site Scripting in the iubenda All-in-one Compliance plugin for WordPress (all versions through 3.13.4) allows unauthenticated attackers to persist executable JavaScript in comment content that runs in the WordPress origin for any subsequent visitor, including logged-in administrators. The root cause is an interaction between the plugin's global strtr() substitution logic and WordPress's KSES allowlist: the substitution strips substrings from KSES-permitted tags (such as abbr title attributes and HTML comments), mutating what KSES treated as safe markup into executable elements like img onerror handlers. No public exploit has been identified at time of analysis, but a patched version (3.13.5) is available.
Stored Cross-Site Scripting in the QuickCal WordPress appointment booking plugin (all versions ≤ 1.0.20) permits unauthenticated remote attackers to inject persistent JavaScript payloads into pages rendered by the booking calendar. The attack is enabled by a design flaw in which the nonce protecting the `booked_add_appt` AJAX action is publicly embedded in any page displaying the booking shortcode, completely nullifying its role as an access control mechanism and allowing any visitor to submit malicious input without credentials. Once stored, the payload executes in the browser context of every subsequent user who views an injected page, enabling session hijacking, credential theft, or redirection to attacker-controlled infrastructure. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV.
Stored Cross-Site Scripting in the Gravity Forms WordPress plugin (all versions ≤2.10.5) permits unauthenticated attackers to inject persistent malicious scripts via Post Body Field Values that survive WordPress's standard wp_kses_post sanitization. The bypass exploits a client-side tooltip component that re-parses aria-label attribute content as innerHTML - stripping script tags but leaving event-handler attributes such as onerror intact and executable - meaning any user who subsequently loads an affected page runs the attacker-controlled JavaScript in their browser. No public exploit has been identified at time of analysis, but the zero-privilege injection vector combined with scope-changing browser execution makes this a high-priority patch for any WordPress environment running Gravity Forms.
Insecure Direct Object Reference in BookWyrm's status edit endpoint (EditStatus) through version 0.9.1 exposes followers-only and direct-message reviews to any authenticated user. Because status IDs are sequential and the edit view does not validate the requesting user's visibility permissions against the target status, an authenticated attacker can enumerate integer IDs to retrieve the raw content of private statuses they should not be able to read. No public exploit has been identified at time of analysis, but a public researcher writeup with proof-of-concept reproduction steps exists, lowering the bar for exploitation.
Missing function-level authorization on Metabase's glossary management API allows any authenticated user - regardless of role - to create, modify, and delete instance-wide business glossary entries in versions before 0.63.1. The affected endpoints (POST, PUT, DELETE on glossary routes) perform no data-analyst permission check, meaning a viewer or analyst account can tamper with shared business definitions that administrators and data teams rely on for consistent reporting. No public exploit or CISA KEV listing exists at time of analysis, though a researcher writeup on GitHub (geo-chen/oss) provides technical details and the fix is confirmed in release v0.63.1.
Template mutation endpoints in Arcane before 2.0.0 permit any authenticated low-privilege user to create, modify, or delete compose templates - including instance-wide defaults - without administrator authorization. By injecting malicious container definitions containing privileged flags or host path mounts, an attacker can backdoor shared templates so that when an administrator deploys a stack from them, the containers execute with root-level access to the Docker host. No public exploit code has been identified at the time of analysis; the fix is confirmed in v2.0.0 per the GitHub release tag and VulnCheck advisory.
Authenticated IDOR in BookWyrm through 0.9.1 lets any registered user overwrite other users' reading records via the edit_readthrough function, which accepts a sequential ReadThrough ID without verifying record ownership. An attacker with a valid account can enumerate integer IDs and tamper with arbitrary users' start dates, finish dates, reading progress, and progress mode, corrupting reading statistics and exported data. A public researcher writeup by geo-chen documents the issue in detail; no vendor-released patch has been confirmed at time of analysis.
Unauthorized access to private attribute-view database contents in SiYuan before v3.8.2 is possible for any user holding a Publish reader role. The getAttributeViewKeys endpoint fails to enforce document-level access controls on hidden KeyValues, returning private cell data from rows bound to documents the requesting user cannot legitimately view. Exploitation requires only low-privilege authenticated access (PR:L per CVSS 4.0 vector); no public exploit or active KEV listing has been identified at time of analysis.