Alex

Ocorre um dimensionamento incorreto do buffer de saída ao usar cifras AES key-wrap-with-padding (`EVP aes {128,192,256} wrap pad`). Para entradas que não sejam múltiplas de 8, o OpenSSL pode escrever até 7 bytes além do final do buffer ou Vec do chamador. Isso pode levar à corrupção de heap controlável por um invasor se o comprimento do texto simples for influenciado por ele. Este problema afeta especificamente as funções `CipherCtxRef::cipher update()`, `CipherCtxRef::cipher update vec()` e `symm::Crypter::update()`.

A função `X509Ref::ocsp responders()` retorna URLs de respondedores OCSP da extensão AIA de um certificado como `OpensslString`. A implementação `Deref<Target = str>` envolve bytes brutos usando `str::from utf8 unchecked`. Como o OpenSSL não impõe que a IA5String subjacente seja ASCII, um certificado contendo bytes não-UTF-8 em sua localização de acesso OCSP pode fazer com que o código Rust seguro construa um `&str` que viola o invariante UTF-8, resultando em comportamento indefinido.

Existe um problema onde `Deriver::derive()` e `PkeyCtxRef::derive()` definem a variável `len` como `buf.len()` e a passam como o comprimento de entrada/saída para `EVP PKEY derive`. Ao usar OpenSSL 1.1.x, os algoritmos X25519, X448, DH e HKDF-extract ignoram o `*keylen` recebido e escrevem incondicionalmente o segredo compartilhado completo. Isso pode resultar em um estouro de heap ou pilha se o chamador passar um slice curto.

A função `EVP DigestFinal()` sempre escreve `EVP MD CTX size(ctx)` no buffer `out`. Se o buffer `out` for menor que esse tamanho, a função `MdCtxRef::digest final()` escreve além do seu limite, o que geralmente resulta em corrupção de pilha. Este problema é acessível a partir de Rust seguro.

Trampolins FFI por trás das funções `set psk client callback()`, `set psk server callback()`, `set cookie generate cb()` e `set stateless cookie generate cb()` no `SslContextBuilder` encaminham o `usize` retornado pelo closure do usuário diretamente para o OpenSSL. Isso ocorre sem verificar o valor em relação ao `&mut [u8]` fornecido ao closure, o que pode resultar em estouros de buffer e outras consequências indesejadas.

As APIs `* from pem callback` não validam o comprimento retornado pelo callback do usuário. Um callback de senha que retorna um valor maior do que o buffer fornecido pode fazer com que algumas versões do OpenSSL realizem a leitura excessiva (over-read) deste buffer. O OpenSSL 3.x não é afetado.

A função `aes::unwrap key()` contém uma asserção incorreta relativa ao tamanho do buffer de saída. Ela verifica se `out.len() + 8 <= in .len()`, que é o inverso do invariante pretendido `out.len() >= in .len() - 8`. Consequentemente, a função aceita buffers que são pequenos demais e rejeita buffers maiores. Se um buffer menor do que o necessário for fornecido, a função escreverá além do final de `out` por `in .len() - 8 - out.len()` bytes, resultando em uma escrita fora dos limites (out-of-bounds write) a partir de uma função pública segura. Isso pode ser acionado em aplicações que utilizam AES keywrap e permitem tamanhos de buffer controlados por atacantes.

Foi detectada uma falha de desreferência de ponteiro nulo na função `hugetlbfs fill super` da funcionalidade hugetlbfs (páginas HugeTLB) do kernel do Linux. Esse problema pode permitir que um usuário local provoque uma falha no sistema ou, potencialmente, amplie seus privilégios no sistema.

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%.

O problema está relacionado a uma falha de desreferência de ponteiro NULL na função `submit lookup cmds` do código drivers/gpu/drm/msm/msm gem submit.c do kernel do Linux. Essa falha ocorre devido à falta de verificação do valor de retorno de `kmalloc()`. A exploração desse problema pode permitir que um usuário local cause uma falha no sistema, resultando em uma negação de serviço.

Foi identificada uma falha de liberação dupla no subsistema NTFS3 do kernel do Linux. Esse problema ocorre quando um usuário aciona simultaneamente os comandos remount e umount, permitindo que um usuário local provoque uma falha no sistema ou, potencialmente, eleve seus privilégios no sistema. A falha está relacionada a uma condição de corrida devido ao acesso simultâneo a um recurso, o que pode levar a um erro de liberação dupla. Isso pode afetar a confidencialidade, integridade e disponibilidade de informações protegidas ou permitir que um invasor eleve seus privilégios.

Foram detectadas uma falha de vazamento de memória e possíveis problemas de divisão por zero e estouro de inteiros no kernel do Linux, nas funcionalidades V4L2 e no código de teste vivid. Este problema ocorre quando um usuário aciona ioctls, como o ioctl `VIDIOC S DV TIMINGS`. A falha está relacionada à verificação insuficiente dos dados do usuário. A exploração deste problema poderia permitir que um usuário local causasse uma falha no sistema se o código de teste vivid estiver habilitado.

Foi identificada uma falha do tipo “use-after-free” na funcionalidade de pipes do kernel do Linux. Esse problema decorre da manipulação do pipe após a chamada da função `free pipe info()`, especificamente com a função `post one notification()`. A falha permite que um usuário local cause uma falha no sistema ou, potencialmente, eleve seus privilégios no sistema. A exploração dessa falha pode permitir que um invasor obtenha privilégios elevados.

Um problema de gravação fora dos limites foi corrigido com uma verificação de limites aprimorada, o que poderia permitir que um aplicativo executasse código arbitrário com privilégios de kernel.

O problema está relacionado à exposição de cookies e cabeçalhos de autorização ao seguir redirecionamentos entre origens. Esse problema está presente nas funções `twisted.web.RedirectAgent` e `twisted.web.BrowserLikeRedirectAgent`. A vulnerabilidade permite que um invasor remoto acesse dados confidenciais.

O problema está relacionado a uma falha de desreferência de ponteiro NULL no subsistema BPF do kernel Linux, especificamente na forma como um usuário aciona a função `map get next key` do filtro Bloom do BPF. Essa falha permite que um usuário local provoque uma falha no sistema.