Ignat Korchagin

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 6.6.74 **Descrição** 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`. **Recomendações** Para versões do kernel Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução temporária, considere desativar a funcionalidade Bluetooth até que um patch esteja disponível. Restrinja o acesso à função `l2cap sock create()` para minimizar o risco de exploração. Evite usar a função `bt sock alloc()` em caminhos de código propensos a erros até que o problema seja resolvido.

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 6.6.74 **Descrição** 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()`. **Recomendações** Para versões do kernel Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução alternativa temporária, considere restringir o uso da funcionalidade Bluetooth RFCOMM até que a atualização seja aplicada.

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 6.6.74 **Descrição** 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. **Recomendações** Para versões do kernel do Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução temporária, considere restringir o acesso ao módulo af packet até que um patch esteja disponível.

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 6.6.74 **Descrição** 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. **Recomendações** Para versões do kernel Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução alternativa temporária, considere implementar um tratamento de erros personalizado para limpar o ponteiro `sk` em caso de erro na função `inet6 create()`. Restrinja o acesso à função `inet6 create()` para minimizar o risco de exploração até que a atualização seja aplicada.

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 6.6.74 **Descrição** 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. **Recomendações** Para versões do kernel Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução alternativa temporária, considere implementar um tratamento de erros personalizado para limpar o ponteiro `sk` no objeto `sock` quando `inet create()` falhar.

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 6.6.74 **Descrição** 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. **Recomendações** Para versões do kernel Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução alternativa temporária, considere implementar um tratamento de erros para limpar o ponteiro sk no objeto sock em caso de erro, semelhante à correção aplicada na versão resolvida.

**Nome do software vulnerável e versões afetadas** Versões do kernel do Linux anteriores à 6.6.74 **Descrição** 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. **Recomendações** Para versões do kernel Linux anteriores à 6.6.74, atualize para a versão 6.6.74 ou posterior para resolver o problema. Como solução temporária, considere restringir o acesso à função `can create()` até que um patch esteja disponível. Evite usar o objeto `sk` na função `can create()` afetada até que o problema seja resolvido.

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.

**Nome do Software Vulnerável e Versões Afetadas** Linux kernel (versões afetadas não especificadas) **Descrição** 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. **Recomendações** No momento, não há informações sobre uma versão mais recente que contenha a correção para esta vulnerabilidade.

**Nome do software vulnerável e versões afetadas** Versões do kernel Linux anteriores à 5.16.0-rc5+ **Descrição** 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. **Recomendações** Para resolver o problema, atualize o kernel do Linux para uma versão que inclua a correção para esta vulnerabilidade. Especificamente, as versões anteriores à 5.16.0-rc5+ são afetadas, portanto, a atualização para a 5.16.0-rc5+ ou posterior deve resolver o problema. Observação: as informações fornecidas não especificam a versão exata que inclui a correção, mas está claro que as versões anteriores à 5.16.0-rc5+ são vulneráveis.

**Nome do software vulnerável e versões afetadas** Kernel do Linux (versões afetadas não especificadas) **Descrição** 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. **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** Kernel Linux versão 5.10.20-cloudflare-2021.3.1 **Descrição** 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. **Recomendações** Para resolver esse problema, ajuste `efx->xdp tx queue count` após a verificação para refletir o valor real dos slots inicializados em `efx->xdp tx queues`. Esse ajuste garante que o kernel considere com precisão o número de filas disponíveis, evitando desreferências de ponteiros NULL e falhas subsequentes.