CVE-2026-99759 in Linuxinfo

Summary

by MITRE • 11/20/2026

In the Linux kernel, the following vulnerability has been resolved:

batman-adv: tt: don't drop local events queued during TVLV update

batadv_tt_tvlv_container_update() read the number of local changes without holding changes_list_lock. batadv_tt_local_event() is not serialized by the commit_lock and can queue new events before the changes_list is flushed:

CPU0 CPU1 batadv_tt_tvlv_container_update() num = ...local_changes; batadv_tt_local_event() list_add_tail(...); ...local_changes++; spin_lock_bh(&...changes_list_lock); /* only num events copied but all freed */

The additional events were freed without ever being sent. Other nodes will only notice this via a CRC mismatch and must request the full table.

The number of changes and the changes_list must therefore be taken atomically. Events queued afterwards then stay in the tt.changes_list for the next TT round.

The changes can no longer be kept for the next round when the TVLV buffer allocation fails. But they would be sent with a skipped TTVN anyway, so the other nodes have to request the full table in this case either way. The last changeset is only dropped in this case when the TTVN was incremented. Without new changes, it still describes the current TTVN.

Previously, the unconsumed changes caused a retry of the TVLV container update in the next commit round. Since the changes are now consumed, the next round would only take the path without changes and wait for BATADV_TT_OGM_APPEND_MAX rounds before updating the container again. Until then, the outdated container with the previous TTVN would still be announced. The ogm_append_cnt is therefore reset on failure to retry the update in the next OGM interval.

This doesn't make the CRC consistent with the announced changeset. The local table modifications are still not serialized with the commit and batadv_tt_local_transition_new() can still make a client part of the CRC for which the event is only part of the next TT round. Such an inconsistency is detected by the CRC check of the other nodes and solved via a full table request.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified in the Linux kernel's batman-adv module represents a critical race condition within the translation table management logic, specifically affecting how local topology changes are processed during TVLV container updates. The core technical flaw resides in the function batadv_tt_tvlv_container_update(), which reads the count of pending local changes without acquiring the necessary serialization lock known as changes_list_lock. This lack of atomicity creates a window where concurrent operations can interfere with each other, leading to data inconsistency and loss of critical network state information. The issue is exacerbated by the fact that batadv_tt_local_event() operates independently of the commit_lock, allowing new events to be queued into the list while the update process is attempting to flush or read from it. This asynchronous behavior means that the number of changes recorded at one moment may not reflect the actual contents of the queue when the processing occurs moments later.

In a typical execution scenario involving two CPU cores, this race condition manifests as follows: on one core, batadv_tt_tvlv_container_update() reads the current value of local_changes to determine how many events to process. Simultaneously or shortly after, another core executes batadv_tt_local_event(), which adds new entries to the list and increments the local_changes counter. When the first core proceeds with spin_lock_bh(&changes_list_lock) and copies only the originally read number of events from the queue, it inadvertently leaves newly added events in the buffer. However, due to subsequent cleanup logic or memory management routines associated with the update cycle, these unconsumed additional events are freed without ever being transmitted to other nodes in the mesh network. This results in a silent loss of topology updates that should have been propagated across the batman-adv overlay network.

The operational impact of this vulnerability is significant for the stability and consistency of the mesh network. Because the affected local changes are dropped, other nodes do not receive the updated translation table information via incremental updates. Instead, they detect a mismatch in the Cyclic Redundancy Check (CRC) values when comparing their own tables with those received from neighbors. This CRC discrepancy forces neighboring nodes to request a full table dump rather than accepting an incremental update. While this mechanism prevents immediate data corruption by triggering a synchronization process, it introduces substantial overhead and latency. The network experiences increased control plane traffic due to frequent full-table requests, which can degrade performance in large or dynamic mesh environments where topology changes are common.

To resolve this issue, the kernel developers have implemented atomic operations to ensure that the number of pending changes is read simultaneously with accessing the change list itself. This ensures that any events queued after the initial count was taken remain in the tt.changes_list for subsequent translation table rounds rather than being erroneously discarded. Additionally, specific logic has been added to handle buffer allocation failures more gracefully by resetting the ogm_append_cnt counter. This adjustment allows the system to retry the TVLV container update in the next OGM interval even if the initial attempt fails due to memory constraints. Although this fix does not completely eliminate all potential inconsistencies—such as those arising from batadv_tt_local_transition_new() potentially including clients in a CRC calculation before their events are fully processed—the primary race condition causing data loss has been mitigated, thereby reducing unnecessary full-table requests and improving overall network efficiency.

From a security and standards perspective, this vulnerability aligns with CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization, as the root cause is the failure to properly synchronize access to shared data structures during concurrent execution paths. The impact on availability can be correlated with ATT&CK technique T1498: Network Denial of Service, specifically through resource exhaustion caused by excessive control plane traffic resulting from repeated full-table synchronization requests triggered by CRC mismatches. While this is not a direct exploitation vector for remote code execution or privilege escalation, it represents a reliability flaw that can be leveraged in denial-of-service scenarios within mesh networks to degrade performance and increase latency. Mitigation strategies involve applying the provided kernel patch which enforces atomicity during translation table updates and ensures proper serialization of change list processing. Administrators should ensure their batman-adv modules are updated to versions containing this fix, particularly in environments where high-frequency topology changes occur or where network stability is critical for operational continuity.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Want to stay up to date on a daily basis?

Enable the mail alert feature now!