Greg Kroah-Hartman

Existe um problema no kernel do Linux onde a função `xe vm madvise ioctl()` não valida os índices da Tabela de Atributos de Página (PAT). Especificamente, o uso do modo de coerência `XE COH NONE` com buffers em cache da CPU permite que uma GPU ignore os caches da CPU e leia dados sensíveis obsoletos diretamente da DRAM. Isso ocorre porque, quando o kernel limpa as páginas antes da realocação, a operação de limpeza pode permanecer no cache da CPU como dados sujos, potencialmente vazando informações de páginas liberadas anteriormente pertencentes a outros processos.

Existe um problema na função `memcg reparent list lrus()` onde a entrada xarray de um grupo de controle de memória (memcg) em encerramento é limpa usando `xas store(&xas, NULL)` antes que suas listas por nó sejam reparentadas. Essa sequência cria uma condição de corrida onde uma operação `list lru del()` concorrente pode não encontrar a entrada via `xa load()`, prosseguir para o memcg pai em `lock list lru of memcg()` e executar `list del init()` em um item ainda vinculado à lista do memcg em encerramento. Se outra thread detiver simultaneamente o bloqueio por nó do memcg em encerramento — como durante outro `list lru del()` ou um callback de isolamento `list lru walk one()` — ambas as threads podem modificar os ponteiros `->next` e `->prev` da mesma lista física usando bloqueios diferentes, resultando na corrupção dos links de itens adjacentes.

Um estouro de heap (heap overflow) existe na função `get manuf info()`. O problema ocorre porque a função lê uma quantidade de bytes especificada pelo campo `Size` de uma EEPROM I2C do dispositivo em um buffer alocado com `kmalloc obj()`, que possui um tamanho fixo de 10 bytes. Embora o campo `Size` seja validado em `check i2c image()` para garantir que não exceda 16384 bytes, ele não é verificado em relação ao tamanho real do buffer de destino. Um dispositivo USB malicioso pode definir o campo `Size` para um valor de até 16377, resultando em um estouro de heap de até 16367 bytes. Além disso, a função `valid csum()` itera pelo buffer com base no campo `Size`, agravando o acesso fora dos limites.

Existe um problema no componente `accel/ivpu` onde a função `get info ioctl()` não valida o tamanho da informação retornado pela consulta de informações do fluxo de métricas em relação ao tamanho do buffer alocado. Essa falta de validação pode levar a um estouro de buffer (buffer overflow) caso o firmware retorne um tamanho maior do que o buffer disponível.

Um problema de use-after-free existe no kernel do Linux devido a uma referência de zerocopy ausente nas funções `pskb carve inside header()` e `pskb carve inside nonlinear()`. Ambas as funções copiam o cabeçalho `skb shared info` para um novo buffer via `memcpy()`, o que inclui o ponteiro `destructor arg` (`uarg`) para skbs MSG ZEROCOPY. Como essas funções não chamam `net zcopy get()` para o novo `shinfo`, a contagem de referência `uarg->refcnt` pode ser reduzida a zero prematuramente. Isso leva à liberação precoce de `ubuf info msgzc` enquanto skbs de TX ainda mantêm ponteiros `destructor arg` ativos. Foi verificado que esta falha permite que um usuário local não privilegiado alcance a escalação total de privilégios de root em uma configuração padrão do kernel.

Existe um problema no componente thunderbolt onde a função `tb xdp properties request()` deriva o comprimento de cópia por pacote do cabeçalho de resposta sem verificar se ele cabe no buffer de dados alocado anteriormente. Um peer malicioso pode manipular o campo de comprimento para ser maior que o `data length` declarado, levando a uma corrupção de memória onde o `memcpy` escreve além da alocação `kcalloc`.

Uma falha existe no módulo de criptografia `af alg` do kernel Linux. Ocorre um estouro aritmético ao processar comprimentos de dados associados durante a verificação do tamanho do buffer de transmissão. Um invasor remoto pode disparar isso fornecendo um comprimento de dados associados especialmente criado, o que pode resultar em uma negação de serviço (DoS) causada por instabilidade do sistema.

Existe um estouro de inteiro na função `kvm reset dirty gfn()` dentro do componente Kernel-based Virtual Machine (KVM). Um invasor local com acesso ao `/dev/kvm` pode manipular as entradas do dirty ring para causar um wrap de u64 durante uma adição não verificada. Isso permite que o invasor ignore uma verificação de limites, levando a um carregamento fora de limites de um `kvm rmap head` e a uma limpeza condicional subsequente de `PT WRITABLE MASK` no local de memória apontado pelo ponteiro carregado. Esta falha pode resultar em divulgação de informações ou em uma negação de serviço.

Um problema de dessincronização existe na função `nft inner parse l2l3()` ao processar pacotes IPv6 internos. Embora a função `ipv6 find hdr()` calcule corretamente o deslocamento do cabeçalho de transporte atravessando os cabeçalhos de extensão, esse valor é incorretamente sobrescrito por um cálculo que considera apenas o cabeçalho base IPv6. Isso resulta em uma incompatibilidade entre `inner thoff`, que aponta incorretamente para o início do cabeçalho de extensão, e `l4proto`, que identifica corretamente o protocolo (ex: IPPROTO TCP). Essa discrepância permite a falsificação do cabeçalho de transporte e a potencial evasão de firewall.

Uma falha existe no subsistema drm/xe/dma-buf envolvendo condições de corrida ao lidar com o hook `invalidate mappings` durante a inicialização e anexação de objetos de buffer. Essas corridas ocorrem porque um objeto de buffer pode estar visível na lista de anexos antes de estar totalmente inicializado ou após ter sido liberado devido a uma falha de inicialização. Um invasor poderia explorar essas condições para causar uma condição de Use-After-Free (UAF) ou uma desreferência de ponteiro NULL em `evict flags`, podendo levar à instabilidade do sistema, travamentos e a uma Negação de Serviço (DoS).

Existe uma condição de corrida no subsistema de Unidade de Gerenciamento de Memória de Entrada/Saída (IOMMU), que gerencia como os dispositivos acessam a memória do sistema. Isso ocorre durante a recuperação do dispositivo quando múltiplos domínios de memória são anexados simultaneamente. Especificamente, a função ` iommu group set domain internal()` rejeita anexações de domínio concorrentes se qualquer dispositivo no grupo estiver em recuperação, o que dispara um WARN ON em ` iommu group set domain nofail()`. Isso pode levar a uma condição de Use-After-Free (UAF)—onde o sistema tenta usar memória que já foi liberada—potencialmente permitindo que um invasor local execute código não autorizado ou cause a falha do sistema (negação de serviço).

Uma falha de use-after-free existe na função `ipc idr alloc()` dentro do caminho de checkpoint/restore para alocação de ID de Comunicação Inter-Processos (IPC) SysV. A função encaminha solicitações para `idr alloc()` com um limite superior aberto. Quando o espaço de ID IPC SysV válido está cheio, as alocações podem exceder `ipc mni`, resultando em IDs que usam a codificação de índice normal, mas visam slots incorretos durante a pesquisa e remoção. Isso quebra o estado do IDR e pode deixar um ponteiro pendente na entrada do IDR. Especificamente, para memória compartilhada, a função `shm destroy()` pode liberar um objeto enquanto deixa uma entrada obsoleta que, quando acessada via `/proc/sysvipc/shm`, leva a uma desreferência de memória liberada. Este problema pode ser explorado por atacantes locais para obter escalonamento de privilégios locais para root. Detalhes técnicos incluem: - **Função Vulnerável**: `ipc idr alloc()` - **Variável Vulnerável**: `ids->next id` passada para `idr alloc()` com um limite superior zero.

Um problema de use-after-free ou confusão de tipos existe na implementação SCTP do kernel Linux. Na função `sctp sendmsg()`, o caminho `SCTP SENDALL` itera pelas associações usando `list for each entry safe()`, que armazena a próxima entrada na variável `tmp`. A função chama `sctp sendmsg to asoc()`, que pode liberar o lock do socket dentro de `sctp wait for sndbuf()`. Enquanto o lock está liberado, outra thread pode migrar a associação armazenada para um novo endpoint via `sctp sock migrate()` ou liberá-la devido a um ABORT de rede. Como a variável `tmp` não é revalidada após a readquisição do lock, o iterador pode avançar para um ponteiro obsoleto, resultando em use-after-free se o socket foi fechado, ou confusão de tipos se a associação foi migrada. O caminho de confusão de tipos pode permitir uma chamada indireta controlada via o ponteiro `outqueue.sched->init sid`.

Uma condição de use-after-free ou double-free existe no subsistema wireless mac80211 quando o debugfs está habilitado. Isso ocorre durante conexões MLO (Multi-Link Operation) se a preparação da conexão falhar, fazendo com que a interface seja resetada para non-MLD (Multi-Link Device). Nesse cenário, o sistema falha ao remover a estação associada, levando à corrupção de memória porque a interface virtual (vif) recria toda a sua estrutura de debugfs.

Dois problemas de tratamento de erro existem no driver de gráficos `drm/xe` na função `xe exec queue create ioctl()`. O primeiro problema ocorre quando a função `xe hw engine group add exec queue()` falha; o caminho de erro ignora a `xe exec queue kill()`, o que mantém a fila na lista de filas de execução de computação da VM se a VM estiver no modo de cerca de preempção (preempt fence mode), resultando em um ponteiro pendente (dangling pointer). O segundo problema ocorre quando a `xa alloc()` falha após a `xe hw engine group add exec queue()` ter tido sucesso; o caminho de erro não chama a `xe hw engine group del exec queue()`, deixando a fila vinculada ao grupo do motor de hardware enquanto ela é liberada, causando um uso após a liberação (use-after-free). Um invasor local poderia explorar essas falhas para causar a falha do sistema ou obter privilégios elevados.

Um problema de Use-After-Free existe no componente xfrm do kernel Linux. Após a conclusão da criptografia assíncrona, a função `xfrm input resume()` chama `dev put()` imediatamente na reentrada antes que o buffer de socket (skb) atinja o transport finish. Como o ponteiro `skb->dev` é posteriormente usado dentro do NF HOOK e seu okfn, uma condição de corrida pode ocorrer com o encerramento do dispositivo.

Uma falha de double-free existe no módulo Transparent Inter-Process Communication (TIPC). O problema ocorre na função `tipc buf append()` quando esta manipula incorretamente a memória após a realocação de um buffer de socket (skb). Especificamente, a função `tipc msg validate()` pode realocar o skb que está validando e liberar o antigo; se a validação falhar posteriormente, o caminho de tratamento de erro libera o ponteiro skb original novamente. Esta corrupção de memória pode levar à instabilidade do sistema, negação de serviço ou, potencialmente, à execução de código arbitrário.

Existe um problema no componente `authencesn` do subsistema de criptografia onde a função `crypto authenc esn create()` não valida o `auth->digestsize` antes de copiá-lo para `inst->alg.maxauthsize`. Isso permite a criação de instâncias com um `authsize` padrão inválido entre 1 e 3 bytes ao usar um ahash com um tamanho de digest correspondente, como `cbcmac(cipher null)`. Consequentemente, a interface `AF ALG` pode acionar o processamento de cauda ESN com um comprimento de tag insuficiente, resultando em um acesso fora dos limites (out-of-bounds).

Uma falha no módulo netfilter conntrack ocorre devido ao uso da função `sprintf()` e ao dimensionamento insuficiente do buffer dentro da função `mangle content len()`. Isso pode levar a uma gravação fora dos limites da pilha (stack-out-of-bounds write), um tipo de corrupção de memória onde os dados são gravados além dos limites de um buffer de comprimento fixo na pilha. Este problema poderia potencialmente ser explorado para causar a negação de serviço.

Uma falha no driver de rede ice ocorre durante a transmissão de pacotes de rede. Quando as funções `ice tso()` ou `ice tx csum()` falham, o caminho de erro em `ice xmit frame ring()` libera o buffer de rede (skb), mas o buffer de transmissão (`tx buf`) continua apontando para ele e permanece marcado como válido. Se a interface de rede for desativada antes que outro pacote seja transmitido para sobrescrever o buffer, a função `ice clean tx ring()` chama a `ice unmap and free tx buf()`, que libera o skb por segunda vez. Este double-free pode resultar em um travamento do sistema ou negação de serviço (DoS).