Alex

Incorrect output buffer sizing occurs when using AES key-wrap-with-padding ciphers (`EVP aes {128,192,256} wrap pad`). For inputs that are not a multiple of 8, OpenSSL may write up to 7 bytes beyond the end of the caller's buffer or Vec. This can lead to attacker-controllable heap corruption if the plaintext length is influenced by an attacker. This issue specifically affects the functions `CipherCtxRef::cipher update()`, `CipherCtxRef::cipher update vec()`, and `symm::Crypter::update()`.

The `X509Ref::ocsp responders()` function returns OCSP responder URLs from a certificate's AIA extension as `OpensslString`. The `Deref<Target = str>` implementation wraps raw bytes using `str::from utf8 unchecked`. Because OpenSSL does not enforce that the underlying IA5String is ASCII, a certificate containing non-UTF-8 bytes in its OCSP accessLocation can cause safe Rust code to construct a `&str` that violates the UTF-8 invariant, leading to undefined behavior.

An issue exists where `Deriver::derive()` and `PkeyCtxRef::derive()` set the `len` variable to `buf.len()` and pass it as the in/out length to `EVP PKEY derive`. When using OpenSSL 1.1.x, the X25519, X448, DH, and HKDF-extract algorithms ignore the incoming `*keylen` and unconditionally write the full shared secret. This can result in a heap or stack overflow if a caller passes a short slice.

The `EVP DigestFinal()` function always writes `EVP MD CTX size(ctx)` to the `out` buffer. If the `out` buffer is smaller than that size, the `MdCtxRef::digest final()` function writes past its end, which typically results in stack corruption. This issue is reachable from safe Rust.

FFI trampolines behind the functions `set psk client callback()`, `set psk server callback()`, `set cookie generate cb()`, and `set stateless cookie generate cb()` in `SslContextBuilder` forward the user closure's returned `usize` directly to OpenSSL. This occurs without verifying the value against the `&mut [u8]` provided to the closure, which can result in buffer overflows and other unintended consequences.

The `* from pem callback` APIs do not validate the length returned by the user's callback. A password callback returning a value larger than the provided buffer can cause certain versions of OpenSSL to over-read this buffer. OpenSSL 3.x is not affected.

The `aes::unwrap key()` function contains an incorrect assertion regarding the output buffer size. It checks that `out.len() + 8 <= in .len()`, which is the reverse of the intended invariant `out.len() >= in .len() - 8`. Consequently, the function accepts buffers that are too small and rejects larger ones. If a buffer smaller than required is provided, the function writes past the end of `out` by `in .len() - 8 - out.len()` bytes, resulting in an out-of-bounds write from a safe public function. This can be triggered in applications using AES keywrap that allow attacker-controlled buffer sizes.

A null pointer dereference flaw was found in the `hugetlbfs fill super` function in the Linux kernel hugetlbfs (HugeTLB pages) functionality. This issue may allow a local user to crash the system or potentially escalate their privileges on the system.

A flaw was found in the Linux kernel's TUN/TAP functionality, which could allow a local user to bypass network filters and gain unauthorized access to some resources. The issue is related to the incorrect initialization of the socket UID in the `tun chr open()` and `tap open()` functions. This could potentially allow an attacker to impact data integrity or elevate their privileges.

A use-after-free flaw was found in the Linux kernel's netfilter, specifically in the way a user triggers the `nft pipapo remove` function with the element, without a `NFT SET EXT KEY END`. This issue could allow a local user to crash the system or potentially escalate their privileges on the system. The exploitation of this flaw may impact the confidentiality, integrity, and availability of protected information.

The issue is related to the `init cea offsets()` function in the `/arch/x86/mm/cpu entry area.c` module of the Linux kernel's memory management subsystem. It concerns the accessibility of the per-cpu area of memory to user address space. Exploitation of this issue may allow an attacker to access protected information and potentially escalate their privileges. A feature called 'Randomize per-cpu entry area' was implemented to mitigate similar issues, but despite this, there is still a risk of per-cpu entry area leaks. This could enable a local user to gain access to important data in memory and potentially escalate their privileges on the system.

A use-after-free flaw was found in the Linux kernel’s mm/mremap memory address space accounting source code. This issue occurs due to a race condition between `rmap` walk and `mremap()`, allowing a local user to crash the system or potentially escalate their privileges on the system.

A hash collision flaw was found in the IPv6 connection lookup table in the Linux kernel’s IPv6 functionality. This issue can be exploited by a remote attacker through a new kind of SYN flood attack, potentially leading to a denial of service. An attacker with a high bandwidth connection or located in the local network can increase the CPU usage of the server that accepts IPV6 connections up to 95%.

The issue is related to a NULL pointer dereference flaw in the `submit lookup cmds` function of the Linux kernel's drivers/gpu/drm/msm/msm gem submit.c code. This flaw occurs due to the lack of a check of the return value of `kmalloc()`. Exploitation of this issue can allow a local user to crash the system, resulting in a denial of service.

A double-free flaw was found in the Linux kernel’s NTFS3 subsystem. This issue occurs when a user triggers remount and umount simultaneously, allowing a local user to crash or potentially escalate their privileges on the system. The flaw is related to a race condition due to concurrent access to a resource, which can lead to a double-free error. This can impact the confidentiality, integrity, and availability of protected information or allow an attacker to elevate their privileges.

A memory leak flaw and potential divide by zero and Integer overflow were found in the Linux kernel V4L2 and vivid test code functionality. This issue occurs when a user triggers ioctls, such as `VIDIOC S DV TIMINGS` ioctl. The flaw is related to insufficient checking of user data. Exploitation of this issue could allow a local user to crash the system if vivid test code is enabled.

A use-after-free flaw was found in the Linux kernel's pipes functionality. This issue arises from the manipulation of the pipe after the `free pipe info()` function has been called, specifically with the `post one notification()` function. The flaw allows a local user to crash or potentially escalate their privileges on the system. Exploitation of this flaw may enable an attacker to gain elevated privileges.

An out-of-bounds write issue was addressed with improved bounds checking, which may allow an application to execute arbitrary code with kernel privileges.

The issue is related to the exposure of cookies and authorization headers when following cross-origin redirects. This problem is present in the `twisted.web.RedirectAgent` and `twisted.web.BrowserLikeRedirectAgent` functions. The vulnerability allows a remote attacker to access confidential data.

The issue is related to a NULL pointer dereference flaw in the Linux kernel's BPF subsystem, specifically in the way a user triggers the `map get next key` function of the BPF bloom filter. This flaw allows a local user to crash the system.