Paolo Abeni

Foi detectada uma vulnerabilidade do tipo “use-after-free” no kernel do Linux, especificamente no componente net/smc. Essa vulnerabilidade se manifestou quando o contador de referências (refcnt) do LGR/link atingiu 0 prematuramente e entrou no processo de liberação, tornando o acesso aos recursos inseguro. O problema é causado pela liberação repetida do contador de referências do LGR/link, possivelmente devido à chamada repetida da função smc conn free() sem proteção de bloqueio de soquete.

O problema está relacionado a um vazamento de memória no kernel do Linux, especificamente no componente s390/iucv. Quando o sinalizador MSG PEEK é passado para `skb recv datagram()`, ele incrementa a contagem de referências de `skb->users`, mas `iucv sock recvmsg()` não decrementa a contagem de referências ao sair. Isso resulta em um vazamento de memória em `skb queue purge()` e um WARN ON em `iucv sock destruct()` durante o fechamento do soquete. O número estimado de dispositivos potencialmente afetados em todo o mundo não está disponível. Não há informações sobre incidentes reais em que esse problema tenha sido explorado. Os detalhes técnicos sobre a exploração incluem: - O sinalizador `MSG PEEK` é usado na função `skb recv datagram()`. - A contagem de referências `skb->users` é incrementada quando o sinalizador `MSG PEEK` é passado. - A função `iucv sock recvmsg()` não decrementa a contagem de referências `skb->users` ao sair. - O vazamento de memória ocorre em `skb queue purge()`. - Um WARN ON é acionado em `iucv sock destruct()` durante o fechamento do soquete.

Nome do software vulnerável e versões afetadas: Kernel do Linux (versões afetadas não especificadas) Descrição: Foi corrigida uma vulnerabilidade no kernel do Linux relacionada ao módulo `net: arc`, especificamente às funções `dma map single` e `dma unmap single`. O problema surge porque `ndev->dev` e `pdev->dev` não são o mesmo dispositivo, e é necessário usar `ndev->dev.parent`, pois ele possui um `dma mask`. Essa vulnerabilidade pode causar um aviso, conforme observado no log do kernel, indicando um possível problema com a CPU e o PID. Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para essa vulnerabilidade.

Nome do software vulnerável e versões afetadas: Versões do kernel Linux anteriores à 6.6.58 Descrição: O problema decorre de verificações de validade insuficientes na função `qdisc pkt len init()`, especificamente ao processar pacotes `SKB GSO DODGY`. A função `virtio net hdr to skb()` não analisa completamente os cabeçalhos TCP, garantindo apenas que tenham pelo menos 20 bytes de comprimento. Isso permite que um usuário crie um pacote ‘GSO’ malicioso com comprimento total de 80 bytes, composto por um cabeçalho IPv4 de 20 bytes, um cabeçalho TCP de 60 bytes e um `gso size` pequeno, como 8. Como resultado, `virtio net hdr to skb()` identificaria incorretamente esse pacote como um pacote GSO normal, pois o tamanho da carga útil percebido seria maior que `gso size`. Isso pode levar a um underflow em `qdisc skb cb(skb)->pkt len`. Recomendações: Para versões do kernel Linux anteriores à 6.6.58, atualize para a versão 6.6.58 ou posterior para resolver o problema. Como solução temporária, considere implementar verificações adicionais de validade para pacotes `SKB GSO DODGY` a fim de evitar subfluxo em `qdisc skb cb(skb)->pkt len`. Restrinja o uso da função `virtio net hdr to skb()` até que a atualização seja aplicada para minimizar o risco de exploração.

O problema está relacionado às funções `select local address()` e `select signal address()` no componente mptcp do kernel Linux. Essas funções selecionam uma entrada de endpoint de uma lista dentro de uma seção protegida por RCU, mas retornam uma referência a ela, que pode ser lida posteriormente. Se a entrada for desreferenciada após o desbloqueio do RCU, isso pode causar um Use-after-Free, afetando potencialmente a confidencialidade, integridade e disponibilidade das informações protegidas. Uma solução simples é copiar as informações necessárias enquanto estiver dentro da seção protegida por RCU para evitar qualquer risco de Use-after-Free posteriormente.

A vulnerabilidade está relacionada ao uso de um recurso não inicializado no componente de rede do kernel do Linux. Ao usar interrupções MSI/INTx, a variável `wx->num q vectors` não é inicializada, levando a um kernel panic na função `wx alloc q vectors()`. Esse problema pode ser explorado para causar uma negação de serviço.

Nome do software vulnerável e versões afetadas: Kernel do Linux (versões afetadas não especificadas) Descrição: O problema está relacionado a um possível vazamento de memória na função `tipc buf append`. A função ` skb linearize()` não libera o skb quando ocorre uma falha, o que pode causar um vazamento de memória. Para corrigir isso, o código foi modificado para mover `*buf = NULL` após ` skb linearize()`, permitindo que o skb seja liberado no caminho de erro. Essa vulnerabilidade pode ser potencialmente explorada para causar uma negação de serviço. Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para essa vulnerabilidade.

The issue is related to a use-after-free condition in the do vcc ioctl function in the net/atm/ioctl.c module of the Linux kernel, caused by a vcc recvmsg race condition. This could potentially allow an attacker to impact the confidentiality, integrity, and availability of protected information.

O problema está relacionado a uma desreferência de ponteiro NULL na função `sk user ns()`, causada pelo fato de o `skb` recém-alocado não possuir `sk` na função `unix diag get exact()`. Isso pode levar a uma negação de serviço. A função `unix diag get exact()` é usada para obter as informações exatas do soquete. A função `sk diag fill()` também está envolvida, preenchendo as informações do soquete. O `NETLINK CB(in skb).sk` é usado para obter o namespace do usuário.

Uma condição de corrida no gerenciamento de sockets MPTCP do kernel Linux pode levar a um acesso use-after-free (UaF). Isso ocorre quando o socket ouvinte que possui uma solicitação relevante é fechado, liberando subfluxos não aceitos e causando a exclusão de sockets MPTCP pareados. Se o worker do socket MPTCP for executado durante este intervalo de tempo, o acesso a `msk->first` pode resultar em um acesso UaF, pois a limpeza do subfluxo não limpou este campo no socket MPTCP.

Foi resolvida uma falha de acesso fora dos limites de slab no kernel do Linux. A falha foi observada durante a execução de autotestes em um kernel com KASAN habilitado, onde foi relatado um splat fora dos limites de slab, semelhante a uma falha relatada anteriormente. A correção envolve liberar explicitamente a rota em vez de chamar `fib6 info release` em um objeto parcialmente inicializado. Além disso, é necessário resolver a falha de inicialização de `fib6 metrics` quando o chamador fornece um `nh`.

O problema está relacionado ao tratamento de pacotes de túnel UDP pelo kernel do Linux. Quando `NETIF F GRO FRAGLIST` ou `NETIF F GRO UDP FWD` estão habilitados e túneis UDP estão disponíveis, a função `udp gro receive()` pode realizar agregação L4 no nível do túnel UDP externo, levando à corrupção do protocolo interno. Isso pode causar problemas com pacotes que transportam cabeçalhos vxlan, nos quais diferentes IDs vxlan podem ser ignorados ou agregados ao mesmo pacote GSO. Para resolver isso, o caminho de código para `SKB GSO UDP L4` e `SKB GSO FRAGLIST` é ignorado se o pacote puder chegar a um túnel UDP, e `udp gro receive()` é autorizado a realizar GRO via `udp sk(sk)->gro receive`. A verificação implementada é mais ampla do que o necessário, mas cobrir o caso extremo aumentaria a complexidade.

The issue is related to a flaw in the Linux kernel that allows userspace to call functions like `memcpy fromiovecend()` with a zero offset and buffer length, causing a read beyond buffer boundaries. This can lead to a memory access fault and a system halt by accessing an invalid memory address. The exploitation of this issue may allow an attacker to cause a denial of service.

The issue allows local users to gain privileges or cause a denial of service (use-after-free) by leveraging improper access to a certain error field in the ext4 journal stop function.