Syzbot

Existe um problema na função `ovl iterate merged()` onde a variável `err` recebe o valor de `PTR ERR(cache)` antes de verificar se `cache` é um erro usando `IS ERR(cache)`. Quando a operação é bem-sucedida, `err` retém um ponteiro de cache truncado, que pode então ser retornado como um erro não zero incorreto. Este comportamento pode ser acionado durante uma operação de readdir de overlay-sobre-overlay envolvendo a chamada de sistema `getdents64` e a função `ovl cache get()`.

Ocorre uma desreferenciação de ponteiro nulo na função `remove waiter()` quando acionada via `FUTEX CMP REQUEUE PI`. Isso acontece porque `task blocks on rt mutex()` não arma o waiter durante a detecção de deadlock, resultando em `waiter->task` como nil. Adicionalmente, `rt mutex start proxy lock()` chama incorretamente `remove waiter()` após capturar com sucesso o rtmutex.

Um problema de slab-use-after-free existe na função `ipv6 chk acast addr()`. O problema ocorre quando um endereço anycast (aca) é alocado e adicionado à `idev->ac list` sob o `idev->lock`, mas é inserido no hash global `inet6 acaddr lst[]` após a liberação do lock. Um processo de desmontagem de dispositivo concorrente pode remover o aca da `ac list` e tentar excluí-lo do hash antes que a inserção tenha ocorrido. Consequentemente, o aca é posteriormente inserido no hash e, em seguida, liberado enquanto ainda está vinculado, resultando em um nó pendente que leitores podem desreferenciar.

Existe um problema na implementação do High-availability Seamless Redundancy (HSR) onde um aviso é disparado incorretamente na função `hsr addr is self()`. O problema ocorre porque `hsr->self node` é limpo em `hsr del self node()`, que é chamado por `hsr dellink()`. Como `hsr dellink()` é executado antes de `unregister netdevice many()`, cria-se uma janela de tempo na qual um usuário ainda pode acessar o dispositivo enquanto `hsr->self node` já foi limpo, levando ao disparo errôneo de `WARN ONCE()`.

Existe um problema em que uma variável de pilha não inicializada é utilizada na função `rseq exit user update()`. Isso ocorre porque a ordem de avaliação de expressões em uma lista de inicialização é sequenciada de forma indeterminada, de acordo com o padrão C. Especificamente, o compilador pode avaliar `cpu to node(ids.cpu id)` antes que `ids.cpu id` tenha sido inicializado com `task cpu(t)`, resultando em um vazamento de informações do kernel (kernel-infoleak) em `rseq set ids get csaddr()`.

Existe um problema na implementação do TCP onde pode ocorrer um subfluxo (underflow) de contagem de referência na função ` inet csk reqsk queue drop()`, podendo levar a uma condição de use-after-free. Isso ocorre quando o `PREEMPT RT` está habilitado e a função `reqsk queue hash req()` é preempitada após a chamada `mod timer()` mas antes de `refcount set()`. Nesse cenário, um temporizador pode ser disparado e abortar o socket de requisição devido ao fechamento do ouvinte, fazendo com que o socket de requisição perca as contagens de referência necessárias tanto para o ehash quanto para o temporizador. A vulnerabilidade envolve a variável `reqsk->rsk refcnt`.

Existe um problema no módulo hfsplus onde a função `hfs brec read()` não valida se o tamanho do registro no disco corresponde ao tamanho esperado para o tipo de registro que está sendo lido. Ao montar um sistema de arquivos corrompido, a função pode realizar uma leitura parcial, deixando partes da estrutura de dados não inicializadas. Esses dados não inicializados em `tmp.thread.nodeName` são posteriormente copiados por `hfsplus cat build key uni()` e utilizados por `hfsplus strcasecmp()`, o que gera um erro de memória quando os bytes não inicializados são usados como índices de array em `case fold()`.

Ocorre um vazamento de contagem de referência no componente ALSA caiaq do kernel Linux durante a falha de probe. A função `create card()` aumenta a contagem de referência do dispositivo USB usando `usb get dev()`, mas o `usb put dev()` correspondente só é executado através do destrutor `card free()`. Como o destrutor `->private free` é atribuído tardiamente no processo `init card()`, qualquer falha que ocorra antes dessa atribuição—como erros em `usb set interface()`, verificações de tipo de endpoint, `usb submit urb()` ou a troca `EP1 CMD GET DEVICE INFO`—impede a execução de `card free()`. Isso resulta em um vazamento da `struct usb device`, suas alocações de descritor e dados de `device private`.

Existe um problema no sistema de arquivos f2fs onde a função `f2fs finish read bio()` pode acessar dados não inicializados em um folio se o sistema falhar ao ler os dados do dispositivo para esse folio. Isso pode levar a um acesso de valor não inicializado dentro da função `f2fs sanity check node footer()`.

Existe um erro de valor não inicializado onde o `flags valid` não é inicializado antes da chamada da função `vfs fileattr get()`. Este problema ocorre porque a variável `fa` não é tratada com o mesmo mecanismo de inicialização que a estrutura interna `file kattr`, podendo levar a instabilidades em manipuladores de sistema de arquivos, incluindo aqueles usados no WSL e em containers Azure. O problema foi identificado por meio de um relatório KMSAN envolvendo a função `fuse fileattr get()`.

Existe um problema no sistema de arquivos OCFS2 onde a função `ocfs2 validate inode block()` não valida o tamanho dos dados inline ao ler um inode do disco. Em casos de corrupção do sistema de arquivos, a variável `i size` pode exceder a capacidade real de dados inline (`id count`). Essa discrepância faz com que a função `ocfs2 dir foreach blk id()` itere além do buffer de dados inline, resultando em uma condição de use-after-free (UAF)—onde o sistema continua a usar um ponteiro após ele ter sido liberado—ao acessar entradas de diretório através da função `ocfs2 check dir entry()`.

Ocorre um vazamento de contagem de referência em `struct xfrm state` no kernel do Linux. Este problema surge porque a função `xfrm dev unregister()` foi implementada como um no-op, embora a função `xfrm dev state add()` (chamada via `xfrm state construct()`) adquira uma referência para `struct net device`. Consequentemente, quando ocorre um evento `NETDEV UNREGISTER`, a referência ao dispositivo de rede não é liberada corretamente, resultando em um vazamento de memória. O problema é agravado quando o bit `NETIF F HW ESP` é limpo após a referência ter sido adquirida, pois o sistema falha ao descarregar incondicionalmente o estado e a política.

Existe um problema no componente hfs onde o uso de `BUG ON` para detectar estouros em `next id`, `folder count` e `file count` nas informações do super bloco pode ser acionado se o MDB (Master Directory Block) estiver corrompido. Isso leva a uma falha do sistema em vez de um tratamento de erro adequado.

Existe um problema no componente erofs onde dados simples são incorretamente classificados como extensões simples entrelaçadas se a posição inicial e o comprimento físico no disco não estiverem ambos alinhados ao tamanho do bloco. Nesses casos, os dados devem ser tratados como extensões simples deslocadas. Isso pode levar a uma leitura fora dos limites (OOB read)—uma condição em que o sistema lê dados além do final do buffer pretendido—dentro da função `z erofs transform plain()` ao processar uma imagem compactada manipulada contendo extensões simples com comprimentos físicos não alinhados.

Existe uma dependência de bloqueio circular no componente ntfs3, especificamente na função `run unpack ex()`. Este problema ocorre devido a um cenário de deadlock AB-BA, onde `ntfs extend mft()` adquire `ni->file.run lock` seguido de `wnd->rw lock`, enquanto `run unpack ex()` adquire `wnd->rw lock` e subsequentemente tenta adquirir `ni->file.run lock` dentro de `ntfs refresh zone()`. Um deadlock AB-BA é uma situação em que duas threads diferentes estão esperando que a outra libere bloqueios, fazendo com que o sistema trave.

Uma condição de use-after-free existe no componente f2fs do kernel Linux. O problema ocorre na função `f2fs write end io()` quando `sbi->nr pages[F2FS WB CP DATA]` é decrementado para zero. Isso pode levar a uma desreferência de ponteiro NULL na função `f2fs in warm node list()`, pois a função `f2fs put super()` pode definir `sbi->node inode` como NULL simultaneamente. Essa condição de corrida resulta em um pânico do sistema quando o kernel tenta verificar se um folio pertence ao node inode.

Ocorre um estouro no campo de comprimento UDP de 16 bits ao processar pacotes PPPoL2TP superdimensionados com encapsulamento UDP. A função `l2tp xmit core()` não verifica estouros durante a atribuição do campo de comprimento UDP, fazendo com que o valor seja truncado para 16 bits.

Um problema de use-after-free existe no kernel do Linux dentro da função `sk psock verdict data ready()`. O problema ocorre em `unix stream sendmsg()` quando o `sk data ready()` do socket peer é chamado após a liberação do `unix state lock()`. Embora o socket remetente mantenha a contagem de referência do peer, isso não impede o processo `sock orphan()` do peer, o que pode levar à liberação do `sk socket` do peer após um período de graça do RCU (Read-Copy-Update). RCU é um mecanismo de sincronização que permite que múltiplos leitores acessem dados enquanto um escritor os atualiza. Isso pode resultar em um slab-use-after-free ao acessar `sk->sk socket` e `sk->sk socket->ops`.

Um soft lockup pode ocorrer na função `mptcp recvmsg()`. Ao receber dados com as flags `MSG PEEK` e `MSG WAITALL`, o buffer de socket (skb) não é removido da `sk receive queue`. Isso faz com que a função `sk wait data()` encontre continuamente dados disponíveis sem realizar uma espera real, resultando em um loop infinito e um soft lockup do sistema.

Uma falha existe na função `gso features check()`, que é chamada por `netif skb features()`. O problema ocorre quando o sistema lê `iph->frag off` para decidir se `mangleid features` deve ser limpo. O acesso ao cabeçalho IPv4 através de `ip hdr()` ou `inner ip hdr()` depende de offsets de cabeçalho que podem não ser seguros para desreferência direta, particularmente para pacotes injetados a partir de caminhos PF PACKET, podendo levar ao uso de valores não inicializados.