CVE-2024-26752

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

l2tp: pass correct message length to ip6_append_data

l2tp_ip6_sendmsg needs to avoid accounting for the transport header twice when splicing more data into an already partially-occupied skbuff.

To manage this, we check whether the skbuff contains data using skb_queue_empty when deciding how much data to append using ip6_append_data.

However, the code which performed the calculation was incorrect:

 ulen = len + skb_queue_empty(&sk->sk_write_queue) ? transhdrlen : 0;

…due to C operator precedence, this ends up setting ulen to transhdrlen for messages with a non-zero length, which results in corrupted packets on the wire.

Add parentheses to correct the calculation in line with the original intent.

Weakness

The product does not correctly calculate the size to be used when allocating a buffer, which could lead to a buffer overflow.

Affected Software

Potential Mitigations

• Understand the programming language’s underlying representation and how it interacts with numeric calculation (CWE-681). Pay close attention to byte size discrepancies, precision, signed/unsigned distinctions, truncation, conversion and casting between types, “not-a-number” calculations, and how the language handles numbers that are too large or too small for its underlying representation. [REF-7]
• Also be careful to account for 32-bit, 64-bit, and other potential differences that may affect the numeric representation.
• Use a vetted library or framework that does not allow this weakness to occur or provides constructs that make this weakness easier to avoid.
• Use libraries or frameworks that make it easier to handle numbers without unexpected consequences, or buffer allocation routines that automatically track buffer size.
• Examples include safe integer handling packages such as SafeInt (C++) or IntegerLib (C or C++). [REF-106]
• Use automatic buffer overflow detection mechanisms that are offered by certain compilers or compiler extensions. Examples include: the Microsoft Visual Studio /GS flag, Fedora/Red Hat FORTIFY_SOURCE GCC flag, StackGuard, and ProPolice, which provide various mechanisms including canary-based detection and range/index checking.
• D3-SFCV (Stack Frame Canary Validation) from D3FEND [REF-1334] discusses canary-based detection in detail.
• Run or compile the software using features or extensions that randomly arrange the positions of a program’s executable and libraries in memory. Because this makes the addresses unpredictable, it can prevent an attacker from reliably jumping to exploitable code.
• Examples include Address Space Layout Randomization (ASLR) [REF-58] [REF-60] and Position-Independent Executables (PIE) [REF-64]. Imported modules may be similarly realigned if their default memory addresses conflict with other modules, in a process known as “rebasing” (for Windows) and “prelinking” (for Linux) [REF-1332] using randomly generated addresses. ASLR for libraries cannot be used in conjunction with prelink since it would require relocating the libraries at run-time, defeating the whole purpose of prelinking.
• For more information on these techniques see D3-SAOR (Segment Address Offset Randomization) from D3FEND [REF-1335].
• Use a CPU and operating system that offers Data Execution Protection (using hardware NX or XD bits) or the equivalent techniques that simulate this feature in software, such as PaX [REF-60] [REF-61]. These techniques ensure that any instruction executed is exclusively at a memory address that is part of the code segment.
• For more information on these techniques see D3-PSEP (Process Segment Execution Prevention) from D3FEND [REF-1336].
• Run the code in a “jail” or similar sandbox environment that enforces strict boundaries between the process and the operating system. This may effectively restrict which files can be accessed in a particular directory or which commands can be executed by the software.
• OS-level examples include the Unix chroot jail, AppArmor, and SELinux. In general, managed code may provide some protection. For example, java.io.FilePermission in the Java SecurityManager allows the software to specify restrictions on file operations.
• This may not be a feasible solution, and it only limits the impact to the operating system; the rest of the application may still be subject to compromise.
• Be careful to avoid CWE-243 and other weaknesses related to jails.

Related Attack Patterns

• https://cwe.mitre.org/data/definitions/100.html
• https://cwe.mitre.org/data/definitions/47.html

References

• https://git.kernel.org/stable/c/0da15a70395182ee8cb75716baf00dddc0bea38d
• https://git.kernel.org/stable/c/13cd1daeea848614e585b2c6ecc11ca9c8ab2500
• https://git.kernel.org/stable/c/359e54a93ab43d32ee1bff3c2f9f10cb9f6b6e79
• https://git.kernel.org/stable/c/4c3ce64bc9d36ca9164dd6c77ff144c121011aae
• https://git.kernel.org/stable/c/804bd8650a3a2bf3432375f8c97d5049d845ce56
• https://git.kernel.org/stable/c/83340c66b498e49353530e41542500fc8a4782d6
• https://git.kernel.org/stable/c/c1d3a84a67db910ce28a871273c992c3d7f9efb5
• https://git.kernel.org/stable/c/dcb4d14268595065c85dc5528056713928e17243
• https://git.kernel.org/stable/c/0da15a70395182ee8cb75716baf00dddc0bea38d
• https://git.kernel.org/stable/c/13cd1daeea848614e585b2c6ecc11ca9c8ab2500
• https://git.kernel.org/stable/c/359e54a93ab43d32ee1bff3c2f9f10cb9f6b6e79
• https://git.kernel.org/stable/c/4c3ce64bc9d36ca9164dd6c77ff144c121011aae
• https://git.kernel.org/stable/c/804bd8650a3a2bf3432375f8c97d5049d845ce56
• https://git.kernel.org/stable/c/83340c66b498e49353530e41542500fc8a4782d6
• https://git.kernel.org/stable/c/c1d3a84a67db910ce28a871273c992c3d7f9efb5
• https://git.kernel.org/stable/c/dcb4d14268595065c85dc5528056713928e17243
• https://lists.debian.org/debian-lts-announce/2024/06/msg00017.html
• https://lists.debian.org/debian-lts-announce/2024/06/msg00020.html