The JSON API Auth plugin for WordPress up to version 3.1.2 suffers from an authentication bypass vulnerability due to cached session cookie disclosure. The parent plugin caches authenticated responses keyed only by URI and query string, ignoring HTTP method and POST body, causing authenticated cookies to be exposed to unauthenticated GET requests. Attackers can retrieve a valid Administrator session cookie and fully authenticate as the Administrator. Exploitation requires the parent plugin to be active with the Auth controller enabled and a recent legitimate Administrator authentication. The vulnerability has a critical CVSS score of 9.8.
The Event Tickets and Registration plugin for WordPress is vulnerable to generic SQL Injection via the 'orderby' parameter in all versions up to, and including, 5.29.5 due to insufficient escaping on the user supplied parameter and lack of sufficient preparation on the existing SQL query. This makes it possible for authenticated attackers, with contributor-level access and above, to append additional SQL queries into already existing queries that can be used to extract sensitive information from the database. A Contributor-level user can reach the vulnerable code path by supplying a post_id they authored, as the can_access_page() gate requires only post authorship rather than the edit_others_posts capability for post owners.
djehuty is a research data repository system developed by 4TU.ResearchData. Prior to version 26.3.2, An unauthenticated attacker can inject SPARQL into the search/listing queries through three separate parameters. Because the affected queries are read (SELECT) queries, this does not write to the store, but it allows: Cross-graph data exfiltration — e.g. UNION-ing in triples from graphs the request was never scoped to (drafts/private/internal data held in the RDF store); denial of service — expensive or malformed queries that tie up the SPARQL backend / web workers. No account or user interaction is required. This issue has been patched in version 26.3.2.
This package is part of a large family (100+ identified as of September 2026) of near-identical
forks of the Baileys WhatsApp Web library that inject a covert channel-subscription action into
the WhatsApp socket layer. On connect, the injected code issues an authenticated `w:mex` FOLLOW
query (query_id 7871414976211147) against one or more attacker-chosen WhatsApp Channel/Newsletter
JIDs, using the installer's own authenticated WhatsApp session -- silently subscribing the
victim's account to channels it never asked to join.
The target JID(s) are hidden from casual source review via one of several obfuscation techniques
observed across the family: a plain string literal, base64 encoding, base64+XOR, or a char-code
array reconstructed at runtime. Some variants instead fetch a mutable, attacker-controlled remote
JSON/JS list of target JIDs from GitHub or another host at runtime, letting the target list change
after installation without a new npm publish. Every sample in the family shares the same underlying
mechanism (a wrapped/patched socket-connect routine that fires the FOLLOW query some seconds after
connect), even though the package name, JID value(s), and obfuscation/delivery method differ per
fork.
The malicious action abuses the installer's own authenticated WhatsApp session to gain reach and
subscribers for attacker-controlled channels; it does not exfiltrate credentials, establish
persistence, or execute arbitrary remote code.
Affected package: @bottino/baileys (npm), version(s): 1.0.14, 1.0.13, 1.0.12, 1.0.11, 1.0.10, 1.0.9, 1.0.8, 1.0.7, 1.0.6, 1.0.5, 1.0.2, 1.0.1.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (571d52cf3274d95d4824667269921b2e0ad1478fe9f324a74fab0ba377bb9a26)
This fork of Baileys overrides `requestPairingCode` so that when the caller does not supply an explicit `pairKey`, `authState.creds.pairingCode` is set to the fixed literal string `BYPAKI64`. That value is then used as the KDF input for the WhatsApp companion-device link-code encryption via `derivePairingCodeKey(authState.creds.pairingCode, salt)`. Because the pairing code is a known constant baked into the package, anyone who knows the target phone number of the installer's WhatsApp account can complete the companion-device pair flow from a device they control and obtain persistent access to the installer's WhatsApp session (read/send messages, contacts, media) — a full account takeover backdoor against any application built on this library. Additionally, on socket connect the code auto-subscribes the installer's WhatsApp account to a hardcoded newsletter JID `120363418582531215@newsletter` and persists a `basedbysam` flag so the covert subscribe runs once per credential store; this covert action uses the installer's WhatsApp identity without disclosure.
CVE-2026-73975 is a high-severity vulnerability in the 4TUResearchData djehuty research data repository system. Before version 26.3.2, authenticated depositors can inject arbitrary SPARQL commands into state-modifying queries by manipulating the session name. This allows them to write or delete arbitrary triples anywhere in the shared RDF store, compromising the integrity of the entire repository metadata. The vulnerability requires a logged-in account, but self-registration via ORCID or SAML lowers the barrier to exploitation. The issue has been fixed in version 26.3.2.
In Eclipse BaSyx AAS Web UI versions v2-241220 through releases before v2-260924, the shared request handler attached the selected infrastructure's `Authorization` header to outgoing requests without checking the destination origin. In deployments using authentication, an attacker could induce a user to open a crafted Web UI link whose `aas` or `path` query parameter points to an attacker-controlled endpoint. The user's browser would then send the configured Basic Authentication credentials, Bearer token, or an available OAuth2 access token to that endpoint. The attacker could reuse the disclosed credential to access protected AAS services with the victim's privileges. The issue is fixed in v2-260924.
CVE-2026-103261 is a resource exhaustion vulnerability in Tornado Web server versions prior to 6.5.9. The HTTPServerRequest.__init__ method parses query strings without limiting the number of fields, unlike the POST-body parsing path which enforces a 1000-field limit. An attacker can send a GET request with thousands of query parameters, causing excessive CPU usage and blocking Tornado's single-threaded event loop, resulting in denial of service. This vulnerability affects all Tornado servers and can degrade response times for all clients sharing the same IOLoop. The issue is fixed by adding a field-count limit to query string parsing, consistent with the POST-body limit.
The Ad Inserter – Ad Manager & AdSense Ads WordPress plugin up to version 2.8.18 is vulnerable to reflected cross-site scripting (XSS) via the Referer header. This occurs when an ad block uses the '{search-query}' dynamic tag, which processes the HTTP Referer header insufficiently, allowing injection of arbitrary JavaScript. Exploitation requires an ad block configured with this tag and automatic insertion enabled. The vulnerability can lead to script execution in the context of any site visitor, including administrators.
CVE-2026-102109 is a SQL injection vulnerability in Kiteworks Secure Data Forms. It occurs when a value derived from an authenticated user's stored account data is used in a database query without proper sanitization. Exploitation requires an authenticated session and only affects deployments using a specific optional feature. The vulnerability affects versions prior to 9.5.1.
Astro is a web framework for content-driven websites. From 5.2.0 until 8.2.4, the @astrojs/netlify adapter generates regular expressions for Netlify Image CDN remote-image allowlists without anchoring them to the beginning of the URL. Because Netlify evaluates these expressions with RegExp.test(), an allowed origin appearing only in a source URL's path or query can satisfy image.domains or image.remotePatterns while the URL's actual host remains attacker-controlled. An unauthenticated request to the public /.netlify/images endpoint can therefore cause the Image CDN to request attacker-selected URLs and may probe or reach internal services. Netlify egress protections may constrain reachable targets, and image transformation limits direct response exfiltration; no confidentiality or integrity impact has been demonstrated. This issue is fixed in version 8.2.4.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (6457aa73ec15f68e06005977033aaba349467d40e3d406f0810684a43b74fcb5)
The package's preinstall script and its main entry (index.js) both perform identical credential-harvesting: they query the EC2 Instance Metadata Service (IMDSv2) at 169.254.169.254 for the identity document and IAM role security credentials, enumerate the entire process.env, and recursively read /var/run/secrets/ (Kubernetes service-account tokens and mounted secrets). The collected data is POSTed to a hardcoded attacker-controlled host at hrnmn.dd.h4x.tv (paths /save_instance_info_hook from preinstall and /save_instance_info_index from index.js). The destination is unrelated to any legitimate package purpose, there is no user configuration, and the behavior fires automatically on `npm install` via the preinstall lifecycle hook as well as on any `require()`/`import` of the package. The harvested material — temporary AWS IAM credentials, cloud instance identity, arbitrary environment variables (which routinely contain API keys, tokens, and database credentials in CI/build environments), and Kubernetes service-account tokens — grants immediate cross-service access to the installer's cloud and cluster resources.
## Source: ghsa-malware (07386b2d1e2efa71fd38c591953684c11302ad77f1c7943bd542b71fd83184e3)
Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it.
Apache Airflow's Snowflake provider did not validate the connection's `account` and `region` fields before interpolating them into request URLs. The SQL API endpoint is built as `https://{account}.snowflakecomputing.com/api/v2/statements`, so an `account` value containing `/`, `?` or `#` demotes the intended domain to a path, query or fragment and leaves the attacker in control of the request host.
The provider sends that request with an `Authorization: Bearer` header carrying a JWT minted from the connection's private key, or the configured OAuth or programmatic access token. A user who can edit the Snowflake connection but cannot read its secrets — Airflow gives connection-configuration users write-only access to stored credentials, and a `private_key_file` lives on the worker rather than in the connection — can therefore cause a valid token for the account to be delivered to a host of their choosing and replay it against the genuine Snowflake endpoint. No Dag-authoring ability is required: the attacker edits the connection and waits for an existing Dag to use it. The same unvalidated value was also used to build the OAuth token-request URL and the Cortex Agent base URL.
Affects deployments where Snowflake connections are editable by users who are not trusted with the connection's credentials. Users are advised to upgrade to `apache-airflow-providers-snowflake` `6.18.0` or later, which rejects `account` and `region` values containing anything other than letters, digits, `.`, `_` and `-` in every URL the provider builds from them.
CVE-2026-101144 is a medium severity vulnerability in Eleveo Call Recording Software version 9.7.0. It involves improper access controls in the Query Builder component, specifically in the /callrec/searchAction.do file. The flaw allows remote exploitation without user interaction and requires low privileges. Public exploit code has been disclosed, but no vendor response or patch is currently available.
Parse Server is an open source backend server. In versions prior to 8.6.90 and in versions from 9.0.0 prior to 9.10.1-alpha.9, the device token deduplication logic for installation records does not validate the type of client-supplied installation fields before using them to build database queries. An unauthenticated remote attacker who knows only the public application ID can submit non-string values in these fields to inject query operators, causing the deduplication cleanup — which runs with elevated privileges before class-level permissions are evaluated — to delete every device registration in the application or an attacker-chosen subset of them. No account, session token, master key, or user interaction is required. Deleted registrations cannot be recovered on the server, so push notifications cannot be delivered until every client re-registers. Any deployment that exposes the REST API to clients and uses push notifications is affected in its default configuration. Versions 8.6.90 and 9.10.1-alpha.9 fix the issue by rejecting non-string values with a client error and by scoping the deduplication cleanup to the calling application. No workaround other than upgrading is available.
MediaFlow Proxy versions up to and including 2.4.9 contain a server-side request forgery (SSRF) vulnerability in the /proxy routes. This vulnerability arises from missing and incomplete validation of the destination URL specified in the 'd' query parameter. An unauthenticated remote attacker can exploit this flaw to make the proxy server send requests to arbitrary internal URLs, including loopback addresses and cloud metadata endpoints, potentially reading full responses from these internal resources.