The npm package @years18/n8n-nodes-utils-helper-s version 1.0.0 contains malicious code in its postinstall script. This script downloads two tarballs from an unrelated domain with TLS verification disabled, installs Python dependencies unsafely, and executes a Python script. It also collects system information and sends it encoded to a remote server. The package mimics legitimate n8n community node packages but its functional code is a stub, with the malicious activity occurring during installation.
The npm package @years18/n8n-nodes-utils-helper-w version 1.0.0 is a malicious package masquerading as a helper for n8n workflows. It contains a hostile payload executed during installation and when required, which collects system information, probes for Python packages, installs additional malicious Python modules, and runs a staged DDoS attack tool. The payload sends collected data to a remote server over HTTPS with disabled TLS verification, indicating an attempt to exfiltrate information. This package abuses its declared purpose as a cover for malicious activity.
The npm package @years18/n8n-nodes-utils-helper-t version 1.0.0 contains malicious code that executes during installation and runtime. It collects system information and sends it to a remote server, disables TLS verification, and establishes a command channel allowing remote command execution. Additionally, it installs and runs a Python-based DDoS toolkit on the host. The package name is designed to mimic a legitimate n8n community node to trick users into installing it.
The npm package @years18/n8n-nodes-utils-helper-x version 1.0.0 is a malicious package that masquerades as a utility helper for n8n but executes hostile code during installation. It runs a postinstall script that downloads and installs attacker-controlled Python code without TLS verification, allowing arbitrary code execution on the host. The script also collects system information and installation status, sending this data to a remote server, effectively indexing compromised hosts. This behavior is inconsistent with the declared package purpose and indicates a supply chain compromise.
calibre is an e-book manager. Prior to 9.12.0, the calibre Content Server endpoint POST /book-update-annotations/{library_id}/{book_id}/{fmt} in src/calibre/srv/books.py omits needs_db_write=True, causing Router.dispatch() to skip ctx.check_for_write_access() before update_annotations() passes attacker-controlled JSON to db.merge_annotations_for_book(), which allows a readonly user or an anonymous user on an unauthenticated deployment to persist unauthorized book annotation changes. This issue is fixed in version 9.12.0.
DB-GPT v0.8.1 contains an unauthenticated path traversal vulnerability that allows remote attackers to write arbitrary files to any location on the server by injecting directory traversal sequences into the user_id HTTP header of the Python file-upload endpoint. Attackers can send a crafted multipart upload request with a traversal-poisoned user_id header to escape the intended upload directory and write attacker-controlled content to locations such as Python startup hooks, cron directories, or agent scripts, resulting in remote code execution.
A resource allocation vulnerability exists in python-socketio versions prior to 5.16.4 where binary EVENT and ACK messages are stored in memory while waiting for their binary attachments. An attacker can exploit this by sending a binary message and omitting some attachments, causing the server to retain partial messages in memory indefinitely. This can lead to denial of service due to excessive memory consumption. Version 5.16.4 mitigates this by accepting binary packets only from authenticated clients and cleaning up partial messages when clients disconnect.
python-engineio versions prior to 4.13.2 have a vulnerability where incoming message sizes are not properly checked before loading into memory in certain server configurations. This can lead to excessive memory allocation and potential denial of service. The issue affects POST requests using ASGI with long polling transport and WebSocket messages using Aiohttp with WebSocket transport. Version 4.13.2 includes fixes that enforce payload size limits and authentication checks before loading message bodies.
Feast versions prior to 0.67.0 contain a critical vulnerability due to unsafe deserialization of user-defined functions (UDFs) serialized with the 'dill' library. This flaw allows unauthenticated remote attackers to execute arbitrary code on the feature server under default configurations. Authenticated attackers can also bypass authorization checks to achieve arbitrary code execution on the registry server. The vulnerability enables cross-tenant data access and lateral movement within the system. A fix is available in version 0.67.0.
ERPNext is a free and open source Enterprise Resource Planning tool. Prior to 15.118.0 and 16.29.0, the validate_template and render_template calls in erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py render subject, body, and pdf_name fields with unrestricted globals including frappe.utils, allowing an authenticated user with a common operational role to inject template expressions, execute arbitrary server-side code, and read data across the application. This issue is fixed in versions 15.118.0 and 16.29.0.
The UpdateHub OTA client in subsys/mgmt/updatehub/updatehub.c contains an out-of-bounds / uninitialized-memory read in z_impl_updatehub_probe(). The probe response from the UpdateHub server is copied into a heap buffer (metadata) that is correctly NUL-terminated, but a second buffer (metadata_copy) is allocated with k_malloc (unzeroed) and filled with memcpy(metadata_copy, metadata, strlen(metadata)), which omits the terminating NUL. Everything after the copied content remains uninitialized heap.
When the first json_obj_parse() over the array descriptor fails, the code falls back to json_obj_parse(metadata_copy, strlen(metadata_copy), ...). The strlen() call scans past the copied bytes through uninitialized heap and, if no zero byte is found before the end of the allocation, reads beyond the buffer; the resulting over-long length is then parsed as JSON. The probe payload is fully controlled by the (malicious, compromised, or — without the optional CONFIG_UPDATEHUB_DTLS — on-path) UpdateHub server, which can craft a large payload that fails the first parse to drive this path.
The consequence is a read of uninitialized heap, with a worst case of an out-of-bounds read past the metadata_copy allocation that can fault and crash the update thread/device, producing a network-triggerable denial of service. The over-read data is consumed only internally to evaluate the update and is not returned to the attacker, so there is no direct information disclosure and no out-of-bounds write.
The fix zeroes metadata_copy with memset before the copy, guaranteeing NUL termination and bounding strlen() within the allocation.
CVE-2026-72581 is a server-side request forgery (SSRF) vulnerability in the duhow/xiaoai-patch project. It allows a remote attacker to make the Xiaomi smart speaker perform HTTP requests to arbitrary internal or external URLs. The vulnerability exists because the /auth endpoint in api/main.py uses a user-supplied URL parameter without validating the destination, enabling potential internal network scanning and access to internal services.
The chaintest package on PyPI version 0.1.0 contains malicious code functioning as a cryptocurrency infostealer. It exfiltrates sensitive data from browsers, including cryptowallet extensions and local storage, as well as standalone applications like password managers and cryptowallets. The malware achieves persistence on different platforms, runs a keylogger that alters copied cryptocurrency addresses to attacker-controlled ones, and can execute remote commands from a command-and-control server. It also exfiltrates SSH keys, installs malicious browser extensions, and shares similarities with a known DPRK-linked campaign.
CVE-2026-19375 is a server-side request forgery (SSRF) vulnerability in dmitriiweb article-scraper-mcp version 1.0.0. The flaw exists in the fetch_article function of the news_scraper_mcp/server.py file, where manipulation of the url argument allows an attacker to perform SSRF attacks remotely. The vulnerability has a medium severity with a CVSS score of 5.3. Exploit code is publicly available, but no official patch or vendor response has been provided yet.
A Server-Side Request Forgery (SSRF) vulnerability exists in nltk/nltk versions 3.9.4 and the current develop branch. The `nltk.pathsec.validate_network_url()` function, intended to prevent SSRF by rejecting internal network addresses, fails to reject IPs in the RFC 6598 shared address space (`100.64.0.0/10`). This occurs because Python's `ipaddress` module does not classify such addresses as `is_private` or `is_global`, and the current guard only checks `is_private` and a few explicit categories. An attacker who can influence a URL passed to NLTK's network-loading helpers can exploit this vulnerability to make a strict-mode application send requests to shared-address-space hosts, potentially exposing non-public infrastructure reachable from the application host. The impact is limited to SSRF-style confidentiality exposure, with no code execution claimed.
A path traversal vulnerability exists in parisneo/lollms version 2.1.0, specifically in the SPA catch-all route implemented in `backend/routers/ui.py`. The vulnerability arises from the improper handling of user-controlled path input, which is directly joined into a filesystem path without sanitization or containment checks. URL-encoded dot-dot sequences (`%2e%2e`) bypass Starlette's built-in path normalization and are resolved by Python's `pathlib`, allowing an unauthenticated attacker to read arbitrary files on the server. This issue has been resolved in version 3.
CVE-2026-19246 is a server-side request forgery (SSRF) vulnerability in HKUDS nanobot versions up to 0.2.1. It affects the _download_image_data_url function in the nanobot/providers/image_generation.py component, allowing remote attackers to initiate SSRF attacks. A patch is available on the main branch and planned for release in version 0.3.1.
JupyterHub versions prior to 5.5.0 have a vulnerability where invalid input to form-based login authenticators allows unauthenticated attackers to place unbounded attacker-controlled usernames in failed-login logs. This can lead to resource exhaustion of logging and storage. The issue is fixed in version 5.5.0.