All tracked items across vulnerabilities, news, research, incidents, and regulatory updates.
A vulnerability in the Linux kernel's fuse (filesystem in userspace) module occurs when a queue pointer is published without proper memory ordering guarantees, potentially allowing other threads to read partially initialized data. The fix requires using smp_store_release() (a memory synchronization operation that ensures all previous writes complete before the pointer assignment) instead of WRITE_ONCE() when publishing the queue, and READ_ONCE() (a volatile read that prevents compiler optimizations from causing race conditions) when reading it.
Fix: The source text indicates the vulnerability is resolved by replacing WRITE_ONCE() with smp_store_release() when publishing the queue pointer in fuse_uring_create_queue(), and using READ_ONCE() in reader code paths that may access the pointer concurrently. However, no specific patch version, CVE status update, or kernel version number where this fix appears is mentioned in the provided content.
NVD/CVE DatabaseIn IBM MQ Agent CD versions 1.0.0, 1.0.1, 2.0.0, and 2.0.1, a logged-in user can send extremely large or computationally expensive requests that tie up the LLM agent workers (the programs handling AI tasks) for very long periods, sometimes over ten minutes each. When many such requests are sent at once, all the available workers become blocked, making the AI Agent feature slow or completely unavailable for other users.
IBM Langflow OSS versions 1.0.0 through 1.11.2 have a vulnerability where authenticated attackers (users with login access) can read any file on the server by tricking the system into treating file paths as input, exposing sensitive data like secret keys (cryptographic material used to secure the system) and databases. The vulnerability bypassed a security setting meant to prevent local file access, specifically in the component that handles chat message attachments sent to language models.
IBM Langflow OSS (open-source software) versions 1.0.0 through 1.11.2 has a vulnerability that lets remote attackers (people accessing the system from outside) steal sensitive information through SSRF (server-side request forgery, where an attacker tricks the server into making requests it shouldn't, potentially accessing internal data).
IBM Langflow OSS (an open-source tool for building AI applications) versions 1.0.0 through 1.11.2 has a vulnerability where a logged-in attacker could exploit a URL parser discrepancy (a difference in how URLs are interpreted) to access sensitive information from internal services.
IBM Langflow OSS (open-source software) versions 1.0.0 through 1.11.2 has a vulnerability where an authenticated attacker (someone with valid login credentials) can delete any files or folders on the server because the software doesn't properly restrict which directories users can access. This happens because the application fails to limit file paths (the addresses of files on disk) to only safe, intended locations.
IBM Langflow OSS (open-source software) versions 1.0.0 through 1.11.2 has a security flaw where a logged-in attacker could access sensitive information by exploiting improper validation of symbolic links (shortcuts to files that can trick a system into reading files it shouldn't).
IBM Langflow OSS (open-source software) versions 1.0.0 through 1.11.2 has a vulnerability that allows an authenticated attacker (someone with login access) to steal sensitive information through SSRF (server-side request forgery, where an attacker tricks the server into making requests to internal systems the attacker shouldn't access).
IBM Langflow OSS (an open-source tool for building AI applications) versions 1.0.0 through 1.11.2 has a vulnerability where sensitive information like credentials is not properly hidden or removed from data. This allows remote attackers (people accessing the system over the internet) to see this sensitive information they shouldn't be able to access.
IBM Langflow OSS (open-source software) versions 1.0.0 through 1.11.2 has a vulnerability where an authenticated attacker (someone with login credentials) can exploit path traversal (a technique that tricks the software into accessing files outside intended directories) to steal sensitive information.
IBM Langflow OSS (open-source software) versions 1.0.0 through 1.11.2 has a security flaw where an authenticated attacker (someone with login credentials) could run arbitrary code (any commands they want) by bypassing authorization checks (security rules that prevent unauthorized actions) in the flow build process (the system that constructs automated workflows).
Microsoft claims that its Copilot chatbot (an AI assistant that answers user questions) rarely copies full sentences or large portions from news articles and books, even when processing chat logs specifically selected to find such copying. The company made these arguments in legal documents while defending itself against copyright lawsuits from The New York Times and other publishers.
A large-scale phishing campaign is using invisible Unicode tag characters (special code points that don't display on screen) to split up financial keywords like 'funding' so email filters cannot recognize them, while the text still appears normal to people reading it. This technique, called ASCII smuggling (hiding messages using invisible characters), adapts AI-era evasion methods to traditional phishing attacks and affected millions of emails between February and May 2026.
IBM Langflow OSS versions 1.0.0 through 1.11.2 have a security weakness where attackers who are logged in can trick the system into thinking they are accessing from localhost (the local computer) by faking an X-Forwarded-For header (a piece of information that says where a request came from). This allows them to bypass security restrictions and modify important configuration files that control IDE (integrated development environment, the tool programmers use to write code) settings.
IBM Langflow OSS versions 1.0.0 through 1.11.2 have a vulnerability where an authenticated attacker can write arbitrary files (any file they choose) to the server. The problem occurs because the SaveToFileComponent doesn't properly validate user input when processing requests, allowing attackers to use path traversal (special sequences that navigate to different directories) to write files outside the intended location.
IBM Langflow OSS (an open-source software tool) versions 1.0.0 through 1.11.2 have a stored cross-site scripting vulnerability (XSS, a type of security flaw where malicious code gets saved in a system and runs when users view it) in its Playground chat feature. This means attackers could inject harmful code through the chat that would execute for other users.
FastChat has a security flaw in its /register_worker endpoint (a part of the software that handles worker registration) where attackers don't need to log in to register fake workers that can intercept user data like prompts and responses. Attackers can also use this vulnerability to perform SSRF (server-side request forgery, where they trick the server into making requests to internal networks it shouldn't access) to probe internal network ports.
LaVague version 0.2.35 has a remote code execution vulnerability (RCE, where attackers can run commands on a system they don't own) in a component called PythonFromMarkdownExtractor.extract_as_object that unsafely runs Python code generated by an AI model. Attackers can exploit this by injecting malicious code through web pages using indirect prompt injection (tricking the AI by hiding instructions in web content), allowing them to execute harmful commands on the operator's computer without any human review.
OpenAI announced a $1 billion subsidy program called Daybreak for Frontline Defenders to help underfunded organizations protecting critical infrastructure (systems like power grids and water supplies) use AI tools to detect and fix security vulnerabilities. The program addresses the growing gap between AI-assisted cyberattacks (which are becoming faster and more sophisticated) and the defensive capabilities of under-resourced critical infrastructure defenders, with initial priority given to American companies.
Advanced AI models (called frontier AI models, the most capable systems currently available) have already shown they can independently carry out complete cyberattacks (end-to-end compromises, where attackers gain full control of a system) on their own, sometimes even by accident. This threat is expected to become much more serious within the next six months.