Ignat Korchagin

O problema está relacionado ao protocolo Bluetooth L2CAP no kernel do Linux. Especificamente, na função `l2cap sock create()`, um ponteiro pendente para o objeto `sk` pode permanecer vinculado ao objeto `sock` quando ocorre um erro durante a chamada de `bt sock alloc()`. Isso pode levar a uma condição de uso após liberação (use-after-free) em outras partes do código. A função `bt sock alloc()` aloca o objeto `sk` e o vincula ao objeto `sock` fornecido. No entanto, quando ocorre um erro, `l2cap sock alloc()` libera o objeto `sk`, mas o ponteiro pendente permanece vinculado ao objeto `sock`.

Uma vulnerabilidade na implementação do Bluetooth RFCOMM do kernel Linux pode levar a um problema de uso após liberação (use-after-free). Isso ocorre porque `bt sock alloc()` vincula um objeto `sk` alocado ao objeto `sock` fornecido e, se `rfcomm dlc alloc()` falhar, o objeto `sk` é liberado, mas um ponteiro pendente permanece no objeto `sock`. O problema é resolvido trocando as chamadas para `bt sock alloc()` e `rfcomm dlc alloc()`.

Uma vulnerabilidade no kernel do Linux foi resolvida, especificamente no módulo af packet. O problema ocorre após a função sock init data() ser chamada em packet create(), onde o objeto sk alocado é anexado ao objeto sock fornecido. Se ocorrer um erro, packet create() libera o objeto sk, deixando um ponteiro pendente no objeto sock. Isso pode causar erros de uso após liberação (use-after-free) se outro código tentar usar o ponteiro.

Foi corrigida uma vulnerabilidade no kernel Linux, na qual a função `inet6 create()` não liberava corretamente um ponteiro `sk` pendente. A função `sock init data()` anexa o ponteiro `sk` alocado ao objeto `sock` fornecido. Se `inet6 create()` falhar posteriormente, o objeto `sk` é liberado, mas o objeto `sock` retém o ponteiro `sk` pendente, o que pode causar um erro de uso após liberação (use-after-free) posteriormente.

Foi corrigida uma vulnerabilidade no kernel Linux, na qual a função `inet create()` poderia deixar um ponteiro `sk` pendente. A função `sock init data()` anexa o objeto `sk` alocado ao objeto `sock` fornecido. Se `inet create()` falhar posteriormente, o objeto `sk` é liberado, mas o objeto `sock` retém o ponteiro pendente, o que pode criar um problema de uso após liberação (use-after-free) posteriormente. A correção envolve limpar o ponteiro `sk` no objeto `sock` em caso de erro.

Uma vulnerabilidade no kernel do Linux foi resolvida, especificamente no módulo net:ieee802154. O problema ocorre quando a função `ieee802154 create()` falha, fazendo com que um ponteiro pendente permaneça no objeto sock fornecido após a liberação do objeto sk alocado. Isso pode permitir o uso após a liberação (use-after-free). A função `sock init data()` anexa o objeto sk alocado ao objeto sock fornecido.

Uma vulnerabilidade no kernel do Linux foi resolvida, especificamente na função `can create()`. Em caso de erro, `can create()` libera o objeto `sk` alocado, mas `sock init data()` já o anexou ao objeto `sock` fornecido. Isso deixa um ponteiro `sk` pendente no objeto `sock` e pode causar uso após liberação (use-after-free) posteriormente.

Nome do software vulnerável e versões afetadas: Kernel do Linux (versões afetadas não especificadas) Descrição: Foi resolvida uma vulnerabilidade no kernel do Linux relacionada ao código de rede, na qual o ponteiro `sk` não era limpo corretamente quando `pf->create` falhava. Esse problema foi identificado depois que um commit anterior não resolveu totalmente a questão, pois algumas implementações de `pf->create` não utilizam `sk common release` em seus caminhos de erro. Por exemplo, usar `arping` com um soquete `AF PACKET` pode demonstrar o problema se `packet create` falhar. O problema é que protocolos futuros podem cometer o mesmo erro, por isso é mais fácil limpar explicitamente o ponteiro `sk` ao retornar de `pf->create` em ` sock create`. Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para esta vulnerabilidade.

Um problema de use-after-free existe no código de rede do kernel Linux. O problema ocorre quando a criação de um socket falha, deixando um ponteiro `sk` pendente. Isso pode ser acionado ao anexar uma sonda fentry à função ` sock release()` que chama o auxiliar `bpf get socket cookie()`, e então executar um comando `traceroute -I` em uma máquina virtual recém-inicializada. A falha está localizada na função `sk common release()` no módulo `net/core/sock.c`. Um use-after-free é uma condição em que um programa continua a usar um ponteiro após a memória para a qual ele aponta ter sido liberada, o que pode levar a falhas no sistema ou acesso não autorizado a dados.

A vulnerabilidade está relacionada ao componente veth do kernel Linux, que não verifica adequadamente se há skbs compartilhados ou clonados quando o GRO está habilitado em um dispositivo veth e o TSO está desabilitado no dispositivo par. Isso pode levar a um bug no kernel e potencialmente causar uma negação de serviço. O problema é resolvido ignorando a etapa GRO para skbs compartilhados ou clonados e tentando desclonar os skbs antes de desistir.

O problema está relacionado ao componente KVM (Kernel-based Virtual Machine) do kernel do Linux, especificamente ao módulo x86/mmu (Memory Management Unit). O problema surge quando o iterador é avançado após uma reinicialização devido a uma cessação, o que pode fazer com que a SPTE (Shadow Page Table Entry) de nível superior e suas subentradas sejam ignoradas. Isso pode levar a uma condição de uso após liberação (use-after-free), resultando em corrupção de dados e erros adicionais no kernel. A vulnerabilidade pode ser explorada por um invasor para potencialmente elevar seus privilégios no sistema.

O problema surge porque `efx->xdp tx queue count` é inicialmente inicializado como `num possible cpus()` e posteriormente usado para alocar e percorrer a matriz de pesquisa `efx->xdp tx queues`. No entanto, nem todos os slots da matriz podem ser inicializados com filas reais durante a verificação, resultando em uma desreferência de ponteiro NULL ao executar comandos como `ethtool -S <iface>`. Isso pode levar a uma falha do kernel.