Account takeover in Apache Answer through 2.0.1 allows unauthenticated remote attackers to seize arbitrary user accounts by exploiting a missing authorization check in the external-login OAuth email binding workflow. The attacker crafts a malicious confirmation link and socially engineers a target into clicking it, after which the attacker's external identity is silently bound to the victim's Answer account. No active exploitation has been identified (CISA KEV absent, EPSS at 7th percentile), but the SSVC framework flags the attack as automatable, making phishing-at-scale campaigns mechanically feasible.
Stored Cross-Site Scripting in GeoDirectory WordPress plugin before 2.8.110 allows authenticated editors and higher-privileged users to persist malicious JavaScript via the place-category setting, which is rendered unsanitized on admin pages. The vulnerability is specifically significant in WordPress multisite deployments where the unfiltered_html capability is intentionally revoked for editors, as it bypasses that restriction through the plugin's own inadequate output handling. A public proof-of-concept exists via WPScan, though EPSS at 0.16% (6th percentile) and SSVC exploitation status of 'none' indicate no confirmed active exploitation at time of analysis.
Memory allocation with excessive size value in Apache Lucy (all versions) enables potential denial-of-service and information disclosure against a retired, unsupported search library. The vulnerability stems from CWE-789, where the library processes externally supplied size values without adequate bounds checking, potentially allowing an attacker to trigger abnormal memory allocation behaviour. No patch will ever be released - the Apache Software Foundation has officially retired Lucy and explicitly recommends migration to an alternative; no public exploit has been identified at time of analysis.
Unauthenticated access to the Material Dashboard WordPress plugin's task management AJAX endpoint exposes all WordPress sites running versions up to and including 1.4.10 to task enumeration, arbitrary task execution, and task deletion. The root cause is a missing capability check on the `amd_ajax_target_task_manager()` function, which is registered via the publicly accessible `public_amd_ajax_handler` AJAX action - reachable without any authentication by design of the hook registration. An attacker can enumerate scheduled tasks (potentially exposing PII stored in task parameters), force arbitrary task execution to trigger unintended server-side operations, or delete tasks to disrupt site functionality. No active exploitation confirmed at time of analysis; no public POC code referenced in available data.
Command injection in Fledge's backup-restore upload handler allows an authenticated administrator to execute arbitrary OS commands on the underlying host by uploading a crafted tar archive. The vulnerable function upload_backup() in python/fledge/services/core/api/backup_restore.py constructs a shell command via unsanitized string formatting and passes it directly to os.system(), while filename validation only checks prefix and suffix - a filename such as fledge_backup_$(id>/tmp/pwn).db satisfies both checks while embedding a shell command substitution. CVSS 7.2 (PR:H) reflects the admin privilege prerequisite; no public exploit or CISA KEV listing has been identified at time of analysis, but the technique is trivially reproducible given access.
Unauthenticated access to NeuVector's manager /network/graph API exposes cached network topology data in all versions through 5.4.9, allowing any network-reachable attacker to retrieve sensitive container environment details without credentials. The missing authentication on this endpoint (CWE-202) means the container security platform itself becomes a reconnaissance source, potentially revealing Kubernetes service relationships, container names, and network flow data to adversaries. No public exploit code or active exploitation (KEV) has been identified at time of analysis, but the unauthenticated network vector significantly lowers the bar for exploitation.
Memory corruption in libkcapi's one-shot asynchronous I/O path allows a local process to induce kernel writes into application-owned output buffers after an error return. Affected platforms include Red Hat Enterprise Linux 8, 9, and 10, Red Hat Hardened Images, and OpenShift Container Platform 4. An unprivileged local attacker or a compromised application can exploit this use-after-free-class condition to crash the calling process (high availability impact) or corrupt buffer contents for limited confidentiality and integrity impact. No public exploit code or CISA KEV listing has been identified at time of analysis.
Arbitrary PHP function execution in ShopLentor (woolentor-addons) for WordPress up to and including version 3.3.7 allows authenticated administrators to invoke any PHP callable on the server via the woolentoropt/v1/custom-action REST API endpoint. The root cause is the plugin's handle_action() method passing the user-supplied 'callback' parameter directly into PHP's call_user_func() with no allowlist restriction, enabling full server-side code execution under the web server's privilege context. No public exploit code or CISA KEV listing has been identified at time of analysis; however, the admin-level requirement limits the realistic attacker pool to compromised or malicious site administrators.
Remote code execution in Pluck CMS through 4.7.21 is achievable by any authenticated administrator who exploits a gap in the file upload blacklist: the extension '.php8' is absent from the hardcoded deny-list in data/inc/files.php, allowing a crafted file to be stored and subsequently executed as PHP on servers running PHP 8.x. Reported by TuranSec, this CWE-434 flaw carries a CVSS 7.2 (PR:H), meaning exploitation is constrained to admin-level accounts but delivers full confidentiality, integrity, and availability impact once triggered. No public exploit code or CISA KEV listing is confirmed at time of analysis, but the bypass is trivially reproducible from the CVE description by any administrator with upload access.
Remote code execution in MacCMS10's admin template editor enables authenticated administrators to execute arbitrary OS commands by exploiting an incomplete PHP function blacklist in conjunction with ThinkPHP's native `{if}` template tag. The `Template.php` controller filtered dangerous functions via regex but omitted `exec`, `passthru`, `popen`, `create_function`, `register_shutdown_function`, `register_tick_function`, `show_source`, and `error_log`, allowing payloads such as `{if condition="exec('id > /tmp/pwned.txt')"}{/if}` to pass validation and execute at render time. No public exploit repository has been independently cited and this CVE is not listed in the CISA KEV catalog; an upstream fix was committed on 2026-06-22.
WP-DownloadManager WordPress plugin (all versions prior to 1.69) grants any WordPress administrator holding the manage_downloads capability the ability to achieve full remote code execution by uploading arbitrary PHP files through the unvalidated download-add.php handler. The upload path is additionally constructed from a raw, unsanitized POST parameter, enabling directory traversal into web-accessible locations under WP_CONTENT_DIR where uploaded PHP files execute on direct request. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but the complete absence of server-side file-type controls and path sanitization makes exploitation trivially simple for any attacker who has obtained admin credentials.
SQL injection in Subrion CMS's admin grid sorting helper exposes virtually all admin grid endpoints to authenticated SQL injection via a raw, unescaped `sort` GET parameter interpolated directly into an ORDER BY clause. Any valid admin session can exploit approximately 29 grid controllers - most of which carry no or incomplete column whitelists - using error-based (EXTRACTVALUE) or time-based (SLEEP) techniques to exfiltrate full database contents, including administrator password hashes. No public exploit code or CISA KEV listing has been identified at time of analysis, though the breadth of affected endpoints and straightforward technique make exploitation trivial for any attacker holding admin credentials.
Sandboxed iframe popup restriction bypass in Electron allows untrusted iframe content to open new windows or trigger `setWindowOpenHandler` without user interaction, despite the `allow-popups` keyword being absent from the sandbox attribute. Electron versions prior to 42.0.1, 41.10.3, and 39.8.10 are affected. The bypass occurs because `FrameLoader::StartNavigation` and `WebContents::OpenURLFromTab` in the OpenURL code path did not check the iframe's sandbox popup flags, permitting emulated Ctrl+click events from untrusted JavaScript to create new browsing contexts. No public exploit or CISA KEV listing is confirmed at time of analysis, but the patch diff includes a working proof-of-concept test.
Stored Cross-Site Scripting in VikRentItems - Flexible Rental Management System (WordPress plugin, versions up to and including 1.2.1) allows unauthenticated attackers to inject persistent JavaScript via the customer email field of the public booking checkout form. The payload is stored in the database through the saveorder() function and executes in the browser of any authenticated user - including administrators - who subsequently views the affected order record in the WordPress admin panel. No public exploit or CISA KEV listing has been identified at the time of analysis, but the unauthenticated injection vector and admin-context execution make this a meaningful privilege escalation path on affected sites.
Stored Cross-Site Scripting in the Independent Analytics WordPress plugin (≤2.15.0) permits unauthenticated attackers to plant persistent malicious scripts via the 404 not_found_url tracking mechanism. The flaw exploits a broken sanitization sequence in get_cell_content(): esc_url() encodes special characters as safe URL entities, but a subsequent urldecode() call reconstructs raw HTML before rendering - and wp_kses_post() fails to strip the resulting markup because it explicitly permits img elements and data-* attributes. The attack entry point, the /iawp/search REST endpoint, accepts requests signed with a token that is itself embedded in public-facing page HTML, making injection effectively unauthenticated. No public exploit code has been identified at time of analysis, and this CVE is not listed in CISA KEV.
MLflow's AI Gateway proxy exposes internal network services - including cloud-instance metadata endpoints - to any authenticated user, including read-only accounts, via an unvalidated api_base field in the CreateGatewaySecret endpoint. All MLflow releases through 3.14.0 are affected; the attack requires only basic credentials and no special configuration, making IAM credential theft a realistic outcome for cloud-hosted deployments. No public exploit has been identified at time of analysis, but the two-step attack (create secret, invoke proxy) involves only standard HTTP requests and no technical barrier beyond holding a valid account.
Cross-user chat history disclosure in IBM Langflow OSS 1.0.0-1.10.3 allows any authenticated user to read other users' conversation history by exploiting session_id collision in the MemoryComponent. The MemoryComponent.retrieve_messages and store_message methods validate only session_id when filtering records, omitting flow_id and user_id ownership checks, which exposes multiple REST API endpoints to unauthorized cross-user data access. No public exploit has been identified at time of analysis, but the straightforward exploitation path and High confidentiality impact make this a genuine remediation priority for any multi-user Langflow deployment.
Resource exhaustion in boringproxy through 0.10.0 allows any authenticated user to permanently consume server file descriptors, goroutines, and memory by repeatedly requesting the GET /loading endpoint with arbitrary id parameter values. The handler blindly attempts to receive from a nil channel - a Go-language primitive that blocks forever - with no map-lookup validity check, no HTTP server timeouts, no context cancellation, and no runtime reclamation, meaning each malicious request permanently holds one goroutine (~50 kB stack), one file descriptor, and associated heap memory. Once the server's file descriptor limit is exhausted, all listener Accept calls fail and tunnel traffic forwarding halts for every connected user. A public proof-of-concept writeup exists on GitHub; no CISA KEV listing has been identified at time of analysis.
SQL injection in Mautic's `getLeadIdsByFieldValueAction` endpoint allows any authenticated user to extract arbitrary database contents by supplying a malicious `field` parameter that is concatenated directly into a SQL query as an unvalidated column identifier. The flaw is rooted in Doctrine ORM's structural inability to parameterize SQL identifiers - the only sanitizer applied, `InputHelper::clean()`, HTML-entity-encodes quotes and angle brackets but leaves the spaces, parentheses, and SQL keywords needed for injection entirely intact. No public exploit code and no CISA KEV listing have been identified at time of analysis, but the low authentication barrier (any valid session) makes this a meaningful risk for organizations with untrusted or externally provisioned Mautic accounts.
Remote code execution, arbitrary file write, and privilege escalation vulnerabilities in Jenkins core (through 2.575 / LTS 2.568.1) and multiple plugins expose CI/CD infrastructure to full controller compromise. The most critical issue (CVE-2026-70426) allows agent processes and users with Agent/Connect permission to bypass the JEP-200 deserialization class filter via an unguarded fallback path in the Remoting library, enabling code execution on the Jenkins controller. Two independent arbitrary file write vectors (CVE-2026-70427 via malicious tar archives, CVE-2026-70428 via path traversal in file parameter names) can achieve equivalent controller-level code execution by writing Groovy scripts to JENKINS_HOME/init.groovy.d/ or deploying rogue plugins. No CISA KEV listing or public exploit has been identified at time of analysis, though the Jenkins security team coordinated a pre-announcement, suggesting no known active exploitation at disclosure.
SQL injection in Magistrala's message-readers API exposes PostgreSQL and TimescaleDB backends to arbitrary query manipulation by any authenticated platform user. The unvalidated `format` HTTP query parameter is interpolated directly into raw SQL at the table-name identifier position via Go's `fmt.Sprintf()` in both readers/postgres/messages.go and readers/timescale/messages.go, enabling exfiltration of database contents with high confidentiality impact (CVSS C:H). The wildcard CPE (cpe:2.3:a:absmach:magistrala:*) indicates all known versions are affected; no vendor-released patch has been confirmed in available references, and no public exploit code or CISA KEV listing has been identified at time of analysis.
Server-Side Request Forgery in IBM Langflow OSS 1.0.0 through 1.10.3 enables authenticated low-privilege users to coerce the application server into issuing arbitrary outbound HTTP requests against internal infrastructure. The root cause is unsanitized pass-through of the OLLAMA_BASE_URL parameter directly into requests.get() inside validate_model_provider_key(), with no scheme enforcement, host allowlisting, or private-range (loopback, RFC1918, link-local) filtering. No active exploitation confirmed (not in CISA KEV), but the network-accessible, low-complexity attack path and high confidentiality impact (C:H) make this a meaningful internal-network pivot risk for organizations running Langflow with AI provider integration enabled.
Uninitialized stack memory dereference in the Linux kernel's IPv4 nexthop subsystem (net/ipv4/nexthop.c) enables local low-privileged attackers to cause kernel panic or leak sensitive stack contents on systems built with CONFIG_INIT_STACK_NONE. Versions from 5.13 through stable branches prior to 6.6.148, 6.12.101, 6.18.42, 7.1.6, and 7.2-rc5 are affected. No public exploit code has been identified and EPSS stands at 0.16% (5th percentile), placing this in the low-urgency tier despite a CVSS 7.1 score driven by dual high-impact outcomes.
Path traversal in Livebook's notebook import pipeline allows an attacker who supplies a crafted `.livemd` file to write attacker-controlled content to arbitrary filesystem paths accessible by the Livebook process. Affected versions span 0.11.0 through 0.18.6 and 0.19.0 through 0.19.8, and the attack requires no credentials on the target instance - only that the victim open the malicious notebook and trigger a URL entry fetch. No active exploitation (CISA KEV) or public proof-of-concept has been identified at time of analysis, but the attack surface is realistic given Livebook's design as a notebook-sharing platform.
M-Files Server before version 26.5.16015.3 can be crashed and permanently halted by an authenticated administrator, requiring manual intervention to restore document management services. The vulnerability stems from improper validation of syntactic input correctness (CWE-1286), allowing a privileged user to trigger a process crash from which the server cannot automatically recover. No public exploit code exists and this vulnerability is not listed in CISA KEV, positioning it primarily as an insider-threat or compromised-admin-account risk.
Stack-based buffer overflow in Apache Lucy (all versions) enables potential arbitrary code execution through crafted input triggering memory corruption in the retired C-based search library. All versions are affected with no patch planned, as the Apache Software Foundation has officially retired the project. No public exploit or active exploitation has been identified at time of analysis, but the absence of any future fix makes this a permanent unresolved risk for any remaining deployments.
Out-of-bounds heap read in HDF5's N-Bit filter decompression affects all versions through 2.3.0, allowing an attacker who can deliver a crafted HDF5 file to a user or automated pipeline to trigger application crashes and, in constrained cases, leak adjacent heap memory contents into decompressed dataset values. The three affected functions - H5Z__nbit_decompress_one_byte, H5Z__nbit_decompress_one_nooptype, and H5Z__nbit_decompress_one_atomic - advance a buffer read index without bounding it against the actual compressed chunk size, exploitable whenever H5Dread is invoked, including via common tools like h5ls and h5repack. No public exploit code has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
Session hijacking via OAuth CSRF in Livebook's Livebook Teams identity provider allows an organization-member attacker to bind a victim's browser session to the attacker's own Teams identity. Livebook versions 0.15.0 through 0.18.6 and 0.19.0 through 0.19.8 are affected when the Livebook Teams ZTA provider is configured, as the OAuth callback handler accepts any valid authorization code without verifying it was issued for the current browser session. The attacker cannot authenticate as the victim, but the victim unknowingly operates under the attacker's identity, exposing notebooks, secrets, and uploaded data to the attacker's account. No public exploit code has been identified and active exploitation has not been confirmed by CISA KEV.
Integer underflow in HDF5 through 2.3.0 allows denial of service when processing Fletcher32-filtered datasets with chunk sizes smaller than 4 bytes. The `H5Z__filter_fletcher32` function in `H5Zfletcher32.c` subtracts the 4-byte checksum length from the input buffer size using an unsigned `size_t` without first verifying the buffer meets the minimum size, causing the result to wrap near `SIZE_MAX` and triggering a massively out-of-bounds read inside `H5_checksum_fletcher32`. Any application or pipeline calling `H5Dread` on a crafted HDF5 file - including the standard `h5ls` and `h5dump` utilities - can be crashed; no public exploit code has been identified and this vulnerability is not in CISA KEV.
Null pointer dereference in HDF5 through 2.3.0 allows denial of service when a user opens a crafted file containing a malformed N-Bit filter pipeline message with zero client-data values. The function H5Z__filter_nbit unconditionally reads cd_values[0] through cd_values[4] before checking whether the array is non-NULL or contains at least 5 elements, crashing any application - including the bundled h5ls and h5repack tools - that calls H5Dread on such a dataset. No active exploitation has been confirmed (not listed in CISA KEV) and no EPSS score was available, but the fix diff publicly exposes the exact crash path, lowering the barrier for proof-of-concept development.
HDF5 library through version 2.3.0 crashes with a divide-by-zero when a process opens a crafted file containing mismatched chunk-layout and dataspace dimensionality. The missing rank validation in H5O__layout_decode allows the corrupt metadata to propagate unchecked to H5S__hyper_iter_get_seq_list, where the invalid value causes integer division by zero and application termination. Tools that automatically consume externally-supplied HDF5 files - such as the bundled h5repack utility - are the primary exposure surface; no public exploit code or confirmed active exploitation has been identified at time of analysis.
Insecure Direct Object Reference (IDOR) in the MultiVendorX WordPress plugin before 5.0.11 exposes confidential financial and commission data across vendor accounts. Any authenticated vendor-level user can query a REST API endpoint using an arbitrary store identifier to retrieve another vendor's earnings and commission records, bypassing per-store ownership validation entirely. No active exploitation is confirmed in CISA KEV, but a publicly available exploit exists per WPScan, and the low EPSS score (0.14%, 4th percentile) suggests limited opportunistic scanning activity at this time.
Denial of service in GitHub Enterprise Server allows unauthenticated remote attackers to render an instance fully unresponsive by submitting a crafted form-encoded HTTP POST request containing deeply nested parameters, triggering uncontrolled recursive parsing that exhausts both CPU and the pool of request-handling worker processes. Because parameter parsing occurs before routing and authentication checks, every POST endpoint on the instance serves as a viable attack surface, requiring no foothold or prior knowledge of application structure. No public exploit code has been identified and the vulnerability is not listed in CISA KEV; the CVSS 4.0 E:U modifier confirms no known active exploitation at the time of scoring. GitHub has released patches across four supported release trains.
Local root escalation on the ZTE Nubia Red Magic 11 Air (NX799J) gaming smartphone stems from a built-in PostgreSQL service that runs as root, listens on a device port, and is guarded only by weak credentials. Because PostgreSQL's COPY FROM PROGRAM syntax executes OS commands with the server's privileges, any local app that reaches the database can break out of the Android application sandbox and run commands as root. No public exploit identified at time of analysis, though the technique (weak-cred Postgres plus COPY FROM PROGRAM) is well understood and trivially reproducible.
Session isolation bypass in Electron allows a malicious or compromised Chrome extension loaded into one session to cross session boundaries and access, navigate, and script windows belonging to a completely separate session. Affected are Electron applications prior to versions 39.8.8, 40.9.0, 41.2.1, and 42.0.0-beta.3 that invoke session.loadExtension and rely on multi-session architecture as a security boundary - a narrowly scoped but architecturally significant trust boundary violation. No public exploit code or CISA KEV listing exists at time of analysis; exploitation requires attacker control of an extension the application has explicitly loaded.
Insecure Direct Object Reference in the Groundhogg WordPress plugin (all versions through 4.5.2) allows authenticated users holding the view_contacts capability - most notably the built-in Sales Rep role - to enumerate and retrieve any contact record site-wide via the REST API, bypassing the intended ownership restriction that should limit them to their own assigned contacts. The GET /wp-json/gh/v4/contacts/<id> endpoint performs only a role-level capability check and accepts sequential integer IDs, meaning a Sales Rep can trivially iterate through all contact IDs and extract PII, contact metadata, owner identifiers, admin edit URLs, and - for contacts linked to a WordPress account - that user's full capability set. No public exploit code or active exploitation has been identified at time of analysis, but the attack is low-complexity for any attacker who can register or obtain a Sales Rep account.
Cost Calculator Builder for WordPress exposes live payment gateway credentials to any authenticated site user through a missing authorization check on its calculator export AJAX endpoint. All plugin versions through 3.6.17 are affected; attackers holding a Subscriber-level WordPress account - the lowest authenticated role - can invoke the `cost-calculator-custom-export-run` AJAX action to receive a full configuration export containing Stripe secret keys, PayPal client secrets, Razorpay secret keys, webhook secret keys, and reCAPTCHA secret keys. No public proof-of-concept exploit or CISA KEV listing has been identified at time of analysis, but the attack requires only a valid site account and basic HTTP knowledge, and an upstream fix has been committed to the plugin's trunk repository.
Path traversal in IBM Langflow OSS 1.0.0-1.10.3 allows authenticated low-privilege network attackers to inject directory traversal sequences into the username field, bypassing containment checks. Successful exploitation enables arbitrary directory deletion, cross-tenant data destruction, and deletion of JWT signing keys - the last of which forces platform-wide session invalidation for all users. No public exploit or CISA KEV listing has been identified at time of analysis, though the operational impact in multi-tenant deployments is severe despite the moderate CVSS score of 6.5.
Privilege escalation via command injection in Cisco Integrated Management Controller (IMC) allows authenticated Admin-level attackers to execute arbitrary OS commands and elevate to root on affected Cisco UCS Standalone and E-Series systems. Exploitation requires Admin credentials to the web-based management interface but results in full OS root access, which Cisco rates as High SIR despite a CVSS 6.5 (Medium) score - explicitly noting that root attainment carries security implications beyond what the base score reflects. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.
Second-order SQL injection in the User Access Manager WordPress plugin (versions ≤ 2.3.12) enables authenticated attackers with subscriber-level access to exfiltrate arbitrary data from the WordPress database. The vulnerability is rooted in a stored objectId value that bypasses validation at write time but is later imploded directly into a SQL NOT IN() clause without integer casting or prepared statements, exploiting a classic second-order injection pattern across two distinct code paths. No public exploit code or CISA KEV listing has been identified at time of analysis; however, the low privilege requirement (subscriber-level) and high confidentiality impact make this a meaningful priority on sites with open user registration or untrusted authenticated users.
SQL injection in the WP ERP WordPress plugin (all versions through 1.17.4) allows authenticated CRM Agent-role users to extract arbitrary data from the WordPress database by supplying a crafted 'erpadvancefilter' parameter to the CRM AJAX handler. The root flaw is a sanitization gap: sanitize_text_field strips HTML but preserves single quotes, which are then interpolated verbatim into a single-quoted SQL WHERE clause inside erp_crm_contact_advance_filter() before execution via $wpdb->get_results(), bypassing WordPress's parameterized query protections entirely. No public exploit has been identified at time of analysis, but the vulnerable code paths are fully documented in WordPress plugin trac source references provided by Wordfence.
Prometheus metric label cardinality exhaustion in Red Hat Build of Keycloak allows any authenticated user to crash the service by flooding its metric store with unique entries. When the Keycloak metrics subsystem is active, failed account operations (such as login attempts referencing nonexistent client IDs) cause raw, unsanitized error strings to be registered as Prometheus label values; because Prometheus stores each unique label combination as a distinct time series, a low-privileged attacker can generate an unbounded number of distinct metric entries, consuming JVM heap until the process crashes or becomes unresponsive. No public exploit code and no CISA KEV listing exist at time of analysis, but the low attack complexity and broad authenticated-user surface make this a realistic denial-of-service risk in any deployment where metrics are enabled.
Path traversal in IBM Langflow OSS 1.0.0-1.10.3 exposes arbitrary server filesystem files via a crafted MCP `resources/read` request using URL-encoded traversal sequences. Authenticated low-privilege users can read other users' uploaded documents, the JWT signing secret, the SQLite database, and process environment variables - leaking the JWT secret effectively enables token forgery and full account takeover beyond what the CVSS 6.5 score implies. No public exploit identified at time of analysis; vendor patch is available per IBM advisory.
Unauthenticated SSRF-adjacent resource abuse in Layouts for WPBakery (all versions ≤ 1.1.3) allows any remote attacker to force the WordPress host to issue unlimited outbound HTTP requests to the plugin vendor's external REST API and write the decoded JSON responses directly into the site's wp_options database table. The missing capability check on the wp_ajax_nopriv_handle_sync action (CWE-862) exposes this endpoint to every unauthenticated client with no nonce verification or rate limiting in place. This vulnerability is not listed in CISA KEV and no public exploit code has been identified, but the trivially low attack complexity - unauthenticated, network-reachable, zero prerequisites - makes availability abuse a realistic and automatable threat.
SQL injection in the WP Post Author WordPress plugin (all versions through 3.9.1) enables authenticated attackers with author-level access to extract arbitrary data from the WordPress database. Exploitation follows a deliberate two-step chain: the attacker stores a malicious payload in the `wpma_metabox_authors_list` parameter during post creation or editing, and the injection fires when any administrator loads the post list screen at `/wp-admin/edit.php`, rendering injected SQL results in the Authors column. No public exploit or CISA KEV listing has been identified at time of analysis; however, Wordfence has published a threat-intelligence record and the vulnerable source lines are publicly browsable in the plugin SVN repository.
SQL injection in Relevanssi's Admin Search AJAX handler (both free and Premium editions) allows authenticated WordPress contributors to perform time-based blind SQL injection against the site's database, exposing all stored data including user password hashes and private content. The taxonomy query argument passed through the `args` parameter is sanitized against XSS but never parameterized before SQL interpolation, violating the principle that sanitization and parameterization are distinct concerns. No public exploit has been identified at time of analysis, but the low privilege bar - contributor-level access, attainable on any site with open registration - meaningfully widens the realistic attack surface beyond what the 6.5 CVSS score alone conveys.
Unauthorized configuration takeover in the Udimi Tools WordPress plugin (≤ 3.2) is possible for any subscriber-level authenticated user due to missing capability checks on both the `ajax_disconnect()` and `ajax_connect()` AJAX handlers. An attacker with a valid low-privilege WordPress account can wipe the site's Udimi API key and connected account settings, then replace them with attacker-controlled credentials - effectively hijacking the site's Udimi solo-ad integration and redirecting lead tracking data. No public exploit code or CISA KEV listing exists at time of analysis; EPSS data was not provided.
IV reuse in libkcapi's one-shot symmetric cipher operations allows a remote attacker to weaken data confidentiality for applications processing inputs larger than 64 KiB under stateful modes (CTR or CBC). Affected deployments include Red Hat Enterprise Linux 8, 9, and 10, Red Hat Hardened Images, and OpenShift Container Platform 4. No public exploit or active exploitation has been identified; the AV:N vector reflects an indirect attack path where an adversary induces a vulnerable application to process specially crafted oversized inputs, enabling ciphertext analysis to expose plaintext relationships or recover data.
SQL injection in ChirpStack's SQLite-backend device tag filtering exposes the full database contents to any authenticated user with device-list access. The flaw lives in `chirpstack/src/storage/device.rs` within both `get_count()` and `list()`, where the tag KEY is concatenated into raw SQL via Rust's `format!()` macro while only the tag VALUE receives safe parameterization through Diesel's `.bind()`. Only deployments using the `chirpstack-sqlite` package are affected - the PostgreSQL backend uses Diesel's native JSONB containment operator and is architecturally immune. No public exploit code or CISA KEV listing has been identified at time of analysis.
Authenticated users in IBM Langflow OSS 1.0.0 through 1.10.3 can exploit a privileged built-in component to read arbitrary server-side environment variables, bypassing security controls designed to restrict custom component execution. The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H) confirms this is a low-complexity, network-accessible flaw requiring only standard user credentials, with high confidentiality impact. No active exploitation confirmed via CISA KEV, and no public exploit code has been identified at time of analysis; IBM has released a patch via its support portal.