Xingwei Lee

O problema está relacionado à função `alauda init media()` no kernel do Linux, que pode causar erros de divisão em `alauda read data()` e `alauda write lba()` caso falhe. Isso ocorre porque o membro `uzonesize` da `struct alauda info` permanece 0. A vulnerabilidade pode potencialmente levar a uma negação de serviço. Para resolver o problema, um membro `media initialized` foi adicionado à `struct alauda info`, uma condição em `alauda check media()` foi alterada e uma verificação de erro para o valor de retorno de `alauda init media()` foi adicionada.

Uma vulnerabilidade no kernel do Linux foi resolvida, especificamente um problema de deslocamento fora dos limites na função `dctcp update alpha()`. A vulnerabilidade ocorre quando o parâmetro do módulo `dctcp shift g` é definido com um valor muito grande, causando um expoente de deslocamento que é muito grande para um tipo de 32 bits. Este problema foi desencadeado pela ferramenta syzkaller, que iniciou o fuzzing dos parâmetros do módulo. A vulnerabilidade pode ser explorada definindo o parâmetro `dctcp shift g` para um valor de 100, que é muito grande para o tipo de 32 bits. Para corrigir este problema, o valor máximo de `dctcp shift g` foi limitado usando a função `param set uint minmax()`.

O problema decorre da notificação FUSE NOTIFY RESEND enviada pela chamada de sistema write() em um programa reprodutor. Ocorre em três etapas: (1) `fuse dev read()` é chamado para ler a solicitação INIT, o que é bem-sucedido e define o bit `FR SENT` na solicitação. (2) `fuse dev write()` envia uma notificação USE NOTIFY RESEND, fazendo com que todas as solicitações em processamento sejam reenviadas, e a solicitação INIT é movida de volta para a lista de pendentes. (3) `fuse dev read()` é chamado novamente com um endereço de saída inválido, tentando copiar a solicitação INIT para esse endereço, o que falha devido ao endereço inválido e aciona um aviso em `fuse request end()`. O aviso foi relatado por Lee Bruce e está associado à versão 6.9.0-rc7 do kernel Linux.

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 bug no núcleo USB do kernel Linux, especificamente no arquivo `port.c`, onde a função `disable store()` não verifica se o hub ao qual a porta pertence foi removido simultaneamente antes de desreferenciar o valor retornado por `usb hub to struct hub()`. Isso pode levar a uma desreferência de ponteiro nulo. O mesmo bug existe na rotina `disable show()`. O problema pode ser corrigido adicionando-se uma verificação para `hub == NULL`. Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para essa vulnerabilidade.

O problema está relacionado ao componente mm/secretmem do kernel do Linux, onde a função `folio is secretmem()` depende de que os folios secretmem sejam folios LRU para economizar ciclos. No entanto, os folios podem residir em um lote de folios sem o sinalizador LRU definido ou ter seu sinalizador LRU temporariamente desativado, tornando o sinalizador LRU não confiável para essa finalidade. Isso pode fazer com que `folio is secretmem()` não detecte folios secretmem, permitindo que o GUP-fast consiga obter um folio secretmem e, potencialmente, cause uma falha no kernel ao tentar ler ou gravar no folio. A correção envolve a remoção da verificação não confiável.

O problema está relacionado a um impasse por inversão de bloqueios no componente sockmap do kernel do Linux. Isso ocorre quando um programa de rastreamento BPF exclui elementos de um mapa sockmap/sockhash, e os bloqueios adquiridos durante essa operação não são seguros contra hardirq. Como resultado, é possível ocorrer um impasse devido à inversão de bloqueios. Os bloqueios no sockmap não são seguros contra hardirq por padrão e só devem ser excluídos do contexto de tarefa ou softirq com interrupções habilitadas.

Nome do software vulnerável e versões afetadas: Kernel do Linux (versões afetadas não especificadas) Descrição: O problema está relacionado à função inet defrag do kernel do Linux, que pode causar uma falha ao remontar fragmentos de skb por meio do netfilter ou de módulos semelhantes. A função ip local out() e outras funções podem passar skb->sk como argumento de função, e se o skb for um fragmento e a remontagem ocorrer antes que a chamada de função retorne, o sk não deve ser liberado. Isso afeta fragmentos skb remontados via netfilter ou módulos similares, como openvswitch ou ct act.c, quando executados como parte do pipeline tx. O problema surge quando o skb é refragmentado novamente logo após a chamada de ip do fragment(), o que pode fazer com que head->sk seja copiado para os novos fragmentos e configure um destrutor para sock wfree. Para corrigir esse problema, o orfandamento precisa ser adiado por tempo suficiente para determinar se o skb deve ser enfileirado ou se está concluindo a fila de remontagem. Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para essa vulnerabilidade.

O problema está relacionado a um impasse na função `usb deauthorize interface()`, que pode ocorrer quando outro processo detém o bloqueio e tenta remover a interface. Isso acontece porque a função `interface authorized store()` adquire um bloqueio de dispositivo em um dispositivo ancestral, chamando `usb deauthorize interface()`, que bloqueia o dispositivo USB pai da interface. O impasse ocorre quando `device del()` aguarda a conclusão de todas as chamadas de retorno de atributos sysfs em andamento, mas `usb deauthorize interface()` não pode ser concluída até que o bloqueio do dispositivo seja liberado, e o bloqueio não será liberado até que a remoção seja concluída. A função `sysfs break active protection()` pode ser usada para evitar esse tipo de impasse, instruindo o sysfs a não aguardar a chamada de retorno do atributo.

O problema está relacionado ao componente netlink do kernel do Linux, onde o código de validação ignora um atributo malformado devido à ausência de um tamanho na matriz minlen para NLA BE32. Isso pode levar a um bug de valor não inicializado, causando potencialmente uma negação de serviço. A vulnerabilidade está associada às funções `nla validate range unsigned`, `nla validate int range` e `validate nla` em lib/nlattr.c. Outros atributos, como BITFIELD32, SINT e UINT, também estão ausentes da matriz minlen e devem ser adicionados.

O problema está relacionado ao componente de criptografia do kernel do Linux, especificamente à função algif hash. Quando uma mensagem de comprimento zero é submetida ao hash pela função algif hash e ocorre um erro, a função tenta liberar uma lista SG que nunca foi alocada. Isso pode levar a uma negação de serviço. O erro ocorre devido a um bug no caminho de erro de comprimento zero, onde a lista SG é liberada desnecessariamente.

Foi resolvida uma vulnerabilidade no kernel do Linux, na qual um programa bpf que utiliza `bpf probe read kernel()` para ler a página vsyscall invoca `copy from kernel nofault()`, que, por sua vez, chama ` get user asm()`. Isso aciona uma exceção de falha de página, pois o endereço da página vsyscall não é legível a partir do espaço do kernel. A função `handle page fault()` considera o endereço da página vsyscall como um endereço do espaço do usuário em vez de um endereço do espaço do kernel, resultando na não aplicação da configuração de correção feita pelo bpf e na invocação de `page fault oops()` devido ao SMAP.

O problema está relacionado a uma vulnerabilidade de liberação dupla no sistema de arquivos ext4, especificamente na função `ext4 move extents()`. Essa vulnerabilidade pode causar uma negação de serviço quando o comando `trim` é executado, devido a um bug de divisão por zero acionado em `mb update avg fragment size()`. O problema surge quando a variável `moved len` não é atualizada após a movimentação bem-sucedida de alguns extensos, levando à liberação de extensos sobrepostos duas vezes em `ext4 mb release inode pa()` e `ext4 process freed data()`. Isso resulta no incremento de `bb free` duas vezes, causando o bug de divisão por zero quando `trim` é executado.