Security vulnerabilities, privacy incidents, safety concerns, and policy updates affecting LLMs and AI agents.
LangChain had incomplete validation of f-string templates (a Python feature for inserting variables into text) in some prompt template classes. Attackers who could control the template structure could use attribute access (like `object.field`) or indexing (like `array[0]`) to expose internal data from Python objects being formatted. This issue only affected applications that allow untrusted users to write templates, not those using hardcoded templates or only letting users provide variable values.
Fix: LangChain now applies consistent f-string safety validation across all prompt template classes. The fix rejects templates containing attribute access or indexing syntax (such as `.` or `[]`) and rejects nested replacement fields inside format specifiers (templates with `{` or `}` in the format specification part). This blocks malicious patterns while preserving normal f-string formatting features.
GitHub Advisory DatabaseA security vulnerability (CVE-2026-5803) was found in bigsk1 openai-realtime-ui that allows attackers to perform SSRF (server-side request forgery, where an attacker tricks a server into making unwanted requests to other systems) through the API Proxy Endpoint in server.js by manipulating a query argument, and this flaw can be exploited remotely. The product uses continuous delivery with rolling releases, so specific affected versions are not documented.
n8n-mcp versions 2.47.3 and earlier have an authenticated SSRF vulnerability (server-side request forgery, where an attacker tricks a server into making requests to unintended locations) in multi-tenant HTTP mode. An attacker with a valid authentication token can make the server fetch arbitrary URLs and read the responses, potentially exposing cloud credentials (like AWS IMDS), internal network services, and other sensitive data the server can access.
Zammad, a web-based customer support system, had a server-side template injection vulnerability (a flaw where attackers can inject malicious code into templates that the server processes) in versions before 7.0.1 that could lead to RCE (remote code execution, where an attacker can run commands on a system they don't own). The vulnerability only affects systems where an attacker has administrative access to control the type_enrichment_data configuration setting.
OpenTelemetry's Go SDK has a PATH hijacking vulnerability (PATH hijacking is when an attacker puts a malicious program in a directory that the system searches for commands, so their fake program runs instead of the real one) on BSD and Solaris systems because the `kenv` command is called by its name alone instead of its full path. An attacker with local access can place a malicious `kenv` binary in the system's PATH, which will execute with the application's permissions when OpenTelemetry initializes.
OpenTelemetry Go's OTLP HTTP exporters (tools that send trace, metric, and log data over HTTP) read entire HTTP response bodies into memory without limiting their size, which allows an attacker controlling the collector endpoint to crash the application by sending extremely large responses. This vulnerability affects three exporter components: otlptrace, otlpmetric, and otlplog.
PraisonAI's `execute_code()` function has a critical sandbox escape vulnerability in its subprocess mode. The subprocess uses a blocklist of only 11 forbidden attributes, missing four key attributes (`__traceback__`, `tb_frame`, `f_back`, `f_builtins`) that attackers can chain together through exception handling to access the real Python builtins and execute arbitrary code, completely bypassing the sandbox.
LobeHub's webapi routes use a client-controlled header called `X-lobe-chat-auth` for authentication, but it's only XOR-obfuscated (a simple reversible encoding) with a hardcoded key that's visible in the code. An attacker can forge this header to bypass authentication and access protected routes like chat, model listing, and image generation without logging in, potentially using the server's API credentials or impersonating other users.
NiceGUI has a security flaw where file upload names aren't properly cleaned on Windows. An attacker can use backslashes in filenames to bypass the sanitization check, which only recognizes forward slashes as path separators. This allows them to write files outside the intended upload folder, potentially overwriting important files or running malicious code. Linux and macOS are not affected because they treat backslashes as regular characters in filenames.
IBM Langflow Desktop versions 1.6.0 through 1.8.2 contain a vulnerability that allows an authenticated user (someone who has already logged in) to run arbitrary code on the system. The flaw stems from an insecure default setting that allows deserialization of untrusted data (converting data from an external source back into code without checking if it's safe) in the FAISS component (a component used for similarity searching).
JWCrypto version 1.5.6 has a weakness in its protection against decompression bomb attacks (where compressed data expands to huge sizes). The code only checks the size of the compressed input (limiting it to 250KB), but does not check the size of the decompressed output, allowing an attacker to send a small token that expands to 100MB or more in memory, causing denial of service (a crash from running out of memory) on resource-constrained devices.
A mutation XSS (cross-site scripting, where attackers inject malicious code through HTML) vulnerability was found in the justhtml library when using custom sanitization policies that preserve foreign namespaces like SVG or MathML. Specially crafted input could pass through sanitization appearing safe, but then become dangerous when a browser or parser processes it again. This only affects users with custom policies; the default settings are safe.
LiteLLM had three security flaws that combined to allow attackers to take over user accounts: passwords were stored using weak SHA-256 hashing without salt (making them easy to crack with rainbow tables, which are pre-computed lists of password hashes), the password hashes were exposed in API responses that any logged-in user could access, and the login endpoint accepted raw hashes instead of requiring the actual password (a vulnerability called pass-the-hash). An attacker could retrieve another user's password hash through the API and use it directly to log in as that user.
LibreChat, a ChatGPT alternative with extra features, had a vulnerability in versions before 0.8.4 where it didn't properly validate filenames from its code execution sandbox, allowing attackers to write files anywhere on the server using path traversal (sequences like ../ that navigate to parent directories). Any user able to run code through the sandbox could exploit this to write arbitrary files with the permissions of the LibreChat server.
The java-sdk has a DNS rebinding vulnerability (an attack where a hacker tricks your browser into accessing a private server by manipulating domain name resolution) that allows attackers to make tool calls to local or private MCP (model context protocol, a system for AI agents to interact with tools) servers if you visit a malicious website. This happens because the java-sdk wasn't validating the Origin header (a security check that confirms requests come from trusted sources) before version 1.0.0, violating the MCP specification.
OpenTelemetry-Go has a denial-of-service vulnerability where the library parses multiple `baggage` HTTP headers (a standard for distributed tracing metadata) separately instead of treating them as one combined value. An attacker can send many baggage header lines to force the server to waste CPU and memory on repeated parsing work, even though each individual header stays within size limits, causing high latency and excessive allocations per request.
NVIDIA Triton Inference Server has a vulnerability (CVE-2026-24175) where an attacker can crash the server by sending a malformed request header, potentially causing a denial of service (disruption of normal service). The vulnerability stems from an uncaught exception (an error that the program doesn't handle properly), which allows attackers to exploit this weakness.
NVIDIA Triton Inference Server has a vulnerability (CVE-2026-24174) where an attacker can crash the server by sending a malformed request (a request with incorrect formatting), causing a denial of service (when a system becomes unavailable to legitimate users). The vulnerability stems from incorrect conversion between numeric types (the software not properly handling different number formats).
NVIDIA Triton Inference Server has a vulnerability (CVE-2026-24173) where an attacker can send a malformed request to crash the server, causing a denial of service (when a service becomes unavailable due to an attack). The vulnerability is related to integer overflow or wraparound (when a number exceeds the maximum value a system can store, causing unexpected behavior).
CVE-2026-24147 is a vulnerability in NVIDIA Triton Inference Server (a tool that runs AI models) where an attacker can upload a malicious model configuration file to cause information disclosure (exposing sensitive data) or denial of service (making the system unavailable). The vulnerability stems from improper path traversal (a flaw that lets attackers access files outside intended directories) validation when handling uploaded files.
Fix: Install the patch named 54f8f50f43af97c334a881af7b021e84b5b8310f to address this issue.
NVD/CVE DatabaseFix: Upgrade to n8n-mcp 2.47.4 or later (no configuration changes required). If you cannot upgrade immediately, the source explicitly mentions three workarounds: (1) use egress filtering to block outbound traffic from the n8n-mcp container to private IP ranges (RFC1918: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) and link-local 169.254.0.0/16; (2) disable multi-tenant headers by unsetting ENABLE_MULTI_TENANT and not accepting x-n8n-url / x-n8n-key headers at the reverse proxy if per-request instance switching is not needed; (3) restrict AUTH_TOKEN distribution to fully trusted operators only until you can upgrade.
GitHub Advisory DatabaseFix: This vulnerability is fixed in version 7.0.1. Users should upgrade to Zammad 7.0.1 or later.
NVD/CVE DatabaseFix: Use the absolute path `/bin/kenv` instead of the bare command name. Change line 42 in `sdk/resource/host_id.go` from `r.execCommand("kenv", "-q", "smbios.system.uuid")` to `r.execCommand("/bin/kenv", "-q", "smbios.system.uuid")`.
GitHub Advisory DatabaseFix: Fixed in PR #8108 (https://github.com/open-telemetry/opentelemetry-go/pull/8108).
GitHub Advisory DatabaseFix: Update to LobeHub version 2.1.48 or later, which patches this vulnerability. According to the advisory, the fix involves: stopping use of `X-lobe-chat-auth` as an authentication token, removing the simple apiKey truthiness check as an auth decision, and requiring a real server-validated session, OIDC token (a standard authentication protocol), or validated API key for all protected webapi routes. If client payloads are still needed, they should be signed server-side with an HMAC (a cryptographic signature) or replaced with a normal session-bound backend lookup.
GitHub Advisory DatabaseFix: The actual solution is implemented in version 1.5.7, as noted in the resolving commit. (The source does not provide explicit details of the fix itself, only that v1.5.7 contains the corrected implementation.)
GitHub Advisory DatabaseFix: Upgrade to justhtml version 1.14.0 or later. If you cannot upgrade immediately, keep `drop_foreign_namespaces=True`, avoid allowlisting foreign namespaces for untrusted input, and avoid allowlisting raw-text containers such as `<style>` in custom policies.
GitHub Advisory DatabaseFix: Fixed in v1.83.0. Passwords are now hashed with scrypt (a much stronger algorithm using a random 16-byte salt with parameters n=16384, r=8, p=1). Password hashes are stripped from all API responses. Existing SHA-256 hashes are transparently migrated to the new format on the user's next login.
GitHub Advisory DatabaseFix: This vulnerability is fixed in version 0.8.4.
NVD/CVE DatabaseFix: Users can mitigate this risk by: 1) Running the MCP server behind a reverse proxy (a security layer like Nginx or HAProxy that forwards requests and can validate headers) configured to strictly validate the Host and Origin headers, or 2) Using a framework that inherently enforces strict CORS (cross-origin resource sharing, a browser security feature that controls which websites can access your data) and Origin validation, such as Spring AI.
GitHub Advisory DatabaseFix: The source recommends: "avoid repeated parsing across multi-values by enforcing a global budget and/or normalizing multi-values into a single value before parsing. one mitigation approach is to treat multi-values as a single comma-joined string and cap total parsed bytes (for example 8192 bytes total)." The fix is accepted when allocations and parsing operations stay within 2x of baseline and response latency (p95) stays below 2ms.
GitHub Advisory Database