Duoming Zhou

Existe um problema de vazamento de contagem de referências na função `ax25 dev device down()`, o que pode causar um vazamento de memória quando o dispositivo ax25 está sendo desligado. O problema surge porque a função `ax25 dev device down()` diminui a contagem de referência de `net device` uma ou zero vezes, dependendo se ela passa para `unlock put` ou não. Para resolver esse problema, a contagem de referência de `net device` deve ser diminuída após `dev->ax25 ptr` ser definido como nulo.

Foi identificado um problema de vazamento de memória no kernel do Linux, especificamente no módulo ax25. O problema decorre de vazamentos na contagem de referências nas funções `ax25 addr ax25dev()` e `ax25 dev device down()`, o que pode causar um vazamento de memória. A contagem de referências do objeto `ax25 dev` pode ser aumentada várias vezes em `ax25 addr ax25dev()`, levando a um vazamento de memória. Da mesma forma, em `ax25 dev device down()`, a contagem de referências de `ax25 dev` é definida como 1 e, em seguida, aumentada quando adicionada a `ax25 dev list`, resultando em uma contagem de referências de 2. No entanto, quando o dispositivo está sendo desligado, `ax25 dev device down()` diminui a contagem de referências uma ou duas vezes, dependendo das circunstâncias, causando um vazamento de memória. Para resolver esse problema, foi adicionada uma interrupção em `ax25 addr ax25dev()`, já que é impossível que um ponteiro apareça duas vezes em uma lista. Além disso, a contagem de referências de `ax25 dev` é aumentada uma vez em `ax25 dev device up()` e diminuída após ser removida de `ax25 dev list`.

O problema está relacionado a um bug do tipo “use-after-free” no kernel do Linux, especificamente no módulo watchdog: cpu5wdt.c. Quando o módulo cpu5wdt está sendo removido, o código-fonte utiliza `del timer()` para desativar o temporizador. Se o manipulador do temporizador estiver em execução, `del timer()` não poderá interrompê-lo e retornará diretamente. Se a região de porta for liberada por `release region()` e, em seguida, o manipulador do temporizador `cpu5wdt trigger()` chamar `outb()` para gravar na região que foi liberada, o bug de uso após liberação ocorrerá. Isso pode levar a uma negação de serviço ou outros impactos.

O problema está relacionado a um bug do tipo “use-after-free” na função ax25 dev device down(), causado pelo acesso simultâneo a um recurso, o que leva a uma condição de corrida. Quando o dispositivo ax25 está sendo desligado, a função ax25 dev device down() chama ax25 ds del timer() para limpar o slave timer. No entanto, se o manipulador do temporizador estiver em execução, ax25 ds del timer() retornará diretamente, resultando em bugs de uso após liberação. Um cenário é mostrado abaixo: (Thread 1) | (Thread 2) | ax25 ds timeout() ax25 dev device down() | ax25 ds del timer() | del timer() | ax25 dev put() //LIBERAR | | ax25 dev-> //USAR Para mitigar o bug, quando o dispositivo estiver sendo desconectado, use timer shutdown sync() para parar o temporizador.

O problema está relacionado a um bug de uso após liberação (use-after-free) no subsistema ALSA do kernel do Linux. Esse bug ocorre quando o `snd pcm substream` está sendo fechado e o `aica channel` é desalocado, mas ainda pode ser referenciado na thread de trabalho. A razão para isso é que `del timer()` retorna diretamente, independentemente de o manipulador do temporizador estar em execução ou não, e o worker poderia ser reprogramado no manipulador do temporizador. Para mitigar esse bug, a função `mod timer()` deve ser chamada condicionalmente em `run spu dma()`, e uma operação PCM sync stop deve ser implementada para cancelar tanto o temporizador quanto o worker.

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 de desreferência de ponteiro nulo no kernel do Linux, especificamente no componente wifi: brcmfmac: pcie. Esse bug ocorre quando a memória física se esgota, fazendo com que a função kzalloc() em brcmf pcie download fw nvram() retorne nulo. Como resultado, o uso de get random bytes() para gerar bytes aleatórios no randbuf pode levar a uma referência a ponteiro nulo. Para evitar falhas de alocação, foi adicionada uma função separada para usar um buffer na pilha do kernel para gerar bytes aleatórios no randbuf, o que pode impedir o estouro da pilha do kernel. Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para essa vulnerabilidade.

Um bug de desreferência de ponteiro nulo pode ocorrer no kernel do Linux quando a memória física se esgota, fazendo com que a função `kcalloc()` em `dmirror device evict chunk()` retorne nulo. Se `src pfns` ou `dst pfns` for desreferenciado, esse bug ocorrerá. Além disso, se a função `kcalloc()` falhar, as páginas mapeadas a um bloco não poderão ser removidas. Para resolver esse problema, um sinalizador ` GFP NOFAIL` foi adicionado a `kcalloc()`, e `kcalloc()` foi substituído por `kvcalloc()` para evitar falhas de alocação devido à falta de necessidade de memória fisicamente contígua.

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 de desreferência de ponteiro nulo na função `nfp fl lag do work()`, que pode ocorrer quando a memória física se esgota e `kmalloc array()` retorna nulo. Se `acti netdevs` for desreferenciado, isso pode causar um bug de desreferência de ponteiro nulo. Isso pode levar a uma negação de serviço. Foi adicionado um patch para verificar se houve falha na alocação e reprogramar o trabalho atrasado, caso isso ocorra. 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 do Linux (versões afetadas não especificadas) Descrição: O problema está relacionado a uma desreferência de ponteiro nulo no componente zynq do kernel do Linux. Isso ocorre quando a função kmalloc() em zynq clk setup() retorna nulo devido à falta de memória física e, em seguida, snprintf() é usada para gravar dados no endereço nulo. O patch para este problema utiliza uma variável de pilha para substituir a função kmalloc(). Recomendações: No momento, não há informações sobre uma versão mais recente que contenha uma correção para esta vulnerabilidade.

O problema está relacionado a uma desreferência de ponteiro NULL na função `of pci prop intr map()` do driver PCI do kernel Linux. Isso poderia permitir que um invasor causasse uma negação de serviço. A vulnerabilidade é resolvida retornando um erro por falha na alocação de int map, especificamente retornando -ENOMEM de `of pci prop intr map()` se `kcalloc()` falhar.

The issue is related to a use-after-free bug in the Linux kernel. This bug occurs because the original code puts `flush work()` before `timer shutdown sync()` in `switch drv remove()`, allowing the worker to be rescheduled in `switch timer()` and causing a use-after-free bug. The vulnerability can be exploited to access confidential data, disrupt data integrity, and cause a denial of service.

The issue is related to a use after free flaw in the Linux kernel's integrated infrared receiver/transceiver driver, specifically in the way a user detaches an rc device. This could allow an attacker to crash the system or potentially escalate their privileges. The flaw is associated with the `ene remove()` function in the `ene ir.c` file.

Foi encontrada uma falha crítica no Kernel do Linux, afetando a função `tst timer` do arquivo `drivers/atm/idt77252.c` do componente IPsec. A manipulação leva a um uso após liberação (use after free), que pode ser explorada devido a uma condição de corrida (race condition). Isso pode permitir que um invasor comprometa a confidencialidade, integridade e disponibilidade de informações protegidas.

Uma falha no Kernel do Linux, especificamente na função `nfcmrvl nci unregister dev()` em `drivers/nfc/nfcmrvl/main.c`, pode levar a uma situação de uso após liberação (use after free), permitindo operações de leitura e gravação quando não há sincronização entre a rotina de limpeza e a rotina de download do firmware. Esse problema pode afetar a confidencialidade, a integridade e a disponibilidade das informações protegidas.

Existe um problema de deadlock no kernel Linux, especificamente na função oxu bus suspend(). Isso ocorre devido a um lock ser mantido em uma thread enquanto se aguarda a parada de um timer, e o handler do timer também requerer o mesmo lock, resultando em um bloqueio. O problema surge do uso de del timer sync() dentro da proteção de spin lock irq(), impedindo o handler do timer de obter o lock necessário.

Um problema de deadlock foi encontrado no kernel Linux, especificamente na função sa1100 set termios(). Isso ocorre quando duas threads tentam acessar o mesmo lock, resultando em uma situação em que uma thread espera indefinidamente que a outra libere o lock. O problema surge devido ao uso de del timer sync() enquanto se mantém o sport->port.lock, o qual também é necessário pelo handler do timer. Para resolver isso, o patch move del timer sync() para antes de spin lock irqsave() para prevenir o deadlock.

Existe um problema de deadlock no Kernel Linux, especificamente na função rtllib beacons stop(). Isso ocorre quando duas threads tentam acessar o ieee->beacon lock simultaneamente, fazendo com que uma thread fique bloqueada indefinidamente. O problema decorre do uso de del timer sync() dentro da proteção de spin lock irqsave(), o que impede o handler do timer de obter o lock necessário.

Existe um problema de deadlock no kernel Linux, especificamente na função `ieee80211 beacons stop()`. Isso ocorre quando duas threads tentam acessar o `ieee->beacon lock` simultaneamente, fazendo com que a função bloqueie indefinidamente. O deadlock é resultado da chamada `del timer sync()` aguardar a parada de um timer enquanto mantém o lock, e o handler do timer também requerer o mesmo lock. O problema é resolvido extraindo a chamada `del timer sync()` da proteção do `spin lock irqsave()`, permitindo que o handler do timer obtenha o lock necessário.

Foi identificada uma falha do tipo “use-after-free” na funcionalidade do protocolo AX.25 de rádio amador do kernel do Linux. Esse problema surge na forma como um usuário se conecta ao protocolo, permitindo que um usuário local provoque uma falha no sistema. A falha está relacionada à implementação do protocolo de rádio amador AX.25 e pode ser explorada para causar uma negação de serviço.

O problema está relacionado a uma falha no kernel do Linux que pode ser explorada por um invasor para causar uma falha no sistema, simulando rádio amador a partir do espaço do usuário. Isso resulta em uma vulnerabilidade de referência a ponteiro nulo (null-ptr-deref) e uma vulnerabilidade de uso após liberação de memória (use-after-free). A exploração dessa falha pode permitir que um invasor remoto cause uma negação de serviço.