A vulnerability in the Linux kernel's net/smc component allows a memory leak due to improper handling of a pending queue entry pointer during flow struct reset in smc_llc_flow_stop(). This occurs when a duplicate message sets a pointer after it has been cleared but before flow completion, leading to a lost allocation. The issue has been resolved by freeing the pending queue entry inside the lock before zeroing the flow struct.
A memory management vulnerability in the Linux kernel's SMC (Shared Memory Communications) subsystem was resolved. The flaw involves a failure to free a previously stashed memory allocation (qentry) before overwriting it during a specific state transition in the LLC flow, causing a memory leak. This occurs when transitioning from REQ_ADD_LINK to ADD_LINK states in the smc_llc_event_handler function. The issue affects multiple specific Linux kernel versions used in various Ubuntu HWE edge releases.
A race condition vulnerability in the Linux kernel's OCFS2 cluster filesystem was resolved by synchronizing heartbeat callbacks with the o2net teardown process. The flaw involved use-after-free errors during concurrent teardown and heartbeat callback execution, potentially causing kernel memory corruption. The patch ensures heartbeat callbacks remain registered until local-node teardown completes, preventing stale or conflicting network state updates.
A use-after-free vulnerability in the Linux kernel's rapidio subsystem was resolved by ensuring that a pointer (mport->net) is cleared when rio_add_net() fails. Without this fix, the pointer could reference freed memory, leading to potential double-free scenarios during device unregistering.
A vulnerability in the Linux kernel's KCM (Kernel Connection Multiplexor) subsystem was resolved. The issue involved not holding an RCU read lock while running the BPF parser function kcm_parse_func_strparser(), which could trigger warnings during BPF map operations. This flaw was fixed by ensuring the RCU read lock is held while running the program.
A vulnerability in the Linux kernel's fec network driver was resolved by ensuring that the Precision Time Protocol (PTP) stop function is only called if PTP was previously initialized. The issue involved unconditional calls to fec_ptp_stop() during error handling and device removal, which could stop PTP even when it was not initialized.
A vulnerability in the Linux kernel's fq_pie network scheduler component allows a signed integer overflow due to improper clamping of the default quantum value. This can cause an infinite loop and soft lockup when a device with an abnormally large MTU triggers the overflow. The issue requires CAP_NET_ADMIN privileges in a user namespace to exploit.
A vulnerability in the Linux kernel's net/sched subsystem related to the act_skbmod module has been resolved. The issue involved incorrect length calculations and invalid header warnings triggered by skb_network_header_len() when tcf_skbmod_act() runs at TC ingress. This could cause warnings, underflowed length values, and dropping of valid short packets. The fix corrects length calculations and header handling to prevent these issues.
A concurrency issue in the Linux kernel's RDS congestion map update logic was resolved by using a proper memory barrier function. The flaw could cause a sender blocked on a congested port to remain blocked indefinitely until a signal or next congestion update occurs. This affects specific Linux kernel versions and involves wait queue synchronization errors.
A vulnerability in the Linux kernel's netfilter nf_tables component was resolved by changing the order of hardware offload steps to prevent inconsistent states between offloaded and software rulesets. This issue could cause discrepancies where the network interface card's offloaded ruleset and the software ruleset differ, potentially impacting system integrity. The vulnerability affects specific Linux kernel versions used in various Ubuntu distributions.
A use-after-free vulnerability in the Linux kernel's net/sched sch_teql module was resolved. The issue occurs because skb->dev is set to a slave device during transmission but not restored on failure, leading to stale references and potential use-after-free when the skb is later processed. This can cause kernel memory corruption and crashes. The vulnerability has a CVSS score of 7.8, indicating a medium severity. A fix was implemented to restore skb->dev to the master device after each slave iteration, preventing the stale reference and use-after-free condition.
BragJack is a security research discovery demonstrating how a single browser extension can hijack internal browser agents across five Chromium-based browsers: Chrome, Comet, Edge, Opera Neon, and Claude in Chrome. The attack leverages the declarativeNetRequest (DNR) API to weaken security headers and redirect JavaScript resources, enabling code execution within privileged browser contexts. This allows access to sensitive capabilities such as local file access, browsing history, camera and microphone, and screenshots without user interaction. The research resulted in two CVEs and $20,000 in bounty rewards from major vendors. The vulnerabilities primarily exploit weaknesses in how these browsers handle network requests and security policies within embedded web views. No patch or remediation status is provided in the source data.
A vulnerability in the Linux kernel's network skbuff subsystem (CVE-2026-90049) involves improper handling of skb_zerocopy() error conditions. Specifically, skb_tx_error() is incorrectly called on the source skb during skb_orphan_frags() failure, which prematurely clears ownership flags and completes the zero-copy user argument. This can lead to use-after-free or data corruption when the skb is still in use by other parts of the networking stack, such as Open vSwitch or ESP processing. The issue has been resolved by leaving error reporting to the callers who already handle failure paths appropriately.
A use-after-free vulnerability in the Linux kernel's GTP module was resolved by adding synchronize_net() in the gtp_newlink() error path. The issue involved freeing tid_hash and addr_hash without waiting for an RCU grace period, allowing concurrent access to freed memory. This could lead to memory corruption and potentially impact confidentiality, integrity, and availability.
A campaign named Miasma exploited a vulnerability in the Model Context Protocol (MCP) tool configuration process to gain OS-level access to 73 GitHub repositories, including one owned by Microsoft Azure. The attack leverages the fact that MCP clients trust tool descriptions as executable instructions without re-prompting or sandboxing, allowing malicious edits to MCP config files to run with developer privileges. This attack class, known as MCP tool poisoning, was first documented in 2025 and escalated to real-world exploitation by mid-2026. The campaign abused the approval process tied to server names rather than content, enabling malicious commands to execute automatically after initial approval. OWASP ranks this attack third in its MCP Top 10 threats. Mitigations include rigorous code review of MCP config changes, pinning tool definitions, scoping privileges per tool, maintaining allowlists of MCP servers, and sandboxing agent execution.
CVE-2026-80980 is a published vulnerability related to the net/smc component in Microsoft software version 3.0. The available information is minimal and does not describe the nature of the flaw, its impact, or exploitation details. No CVSS score or patch information is provided.
This vulnerability, identified as CVE-2026-80996, relates to the L2TP (Layer 2 Tunneling Protocol) implementation in Microsoft software. The issue involves the propagation of multicast notification errors, which should not be propagated. No detailed technical or impact information is provided beyond this description.
This vulnerability, identified as CVE-2026-80991, relates to the serialization of PTP (Precision Time Protocol) clock teardown in Microsoft software version 3.0. No detailed technical information or impact description is provided beyond the identification of the vulnerability.
In the Linux kernel, the following vulnerability has been resolved: net/smc: fix socket refcount leak in smc_switch_conns() smc_switch_conns() takes a reference on the SMC socket before dropping lgr->conns_lock, so the connection stays alive while the CDC slot is fetched: sock_hold(&smc->sk); read_unlock_bh(&lgr->conns_lock); /* pre-fetch buffer outside of send_lock, might sleep */ rc = smc_cdc_get_free_slot(conn, to_lnk, &wr_buf, NULL, &pend); if (rc) goto err_out; The err_out label only drops the wr_tx link reference, so this early exit returns without the matching sock_put(). The second error exit is not affected, because sock_put() has already run by then. A leaked sk_refcnt means the smc_sock is never destroyed. Its send and receive buffers stay allocated, and for a user socket the reference held on the network namespace is never released, so the netns can no longer be torn down. smc_cdc_get_free_slot() fails when the target link goes down or when the connection has been killed while the switch is in progress. Both are reachable during the link failover this function implements, so the leak is triggered by the same hardware events that make smc_switch_conns() run in the first place. Restructure so there is a single sock_put() covering both outcomes, instead of adding a second one to the error path.