Dan Carpenter

Foi identificado um problema de corrupção de memória no kernel Linux, especificamente no componente mailbox, th1520. As funções `th1520 mbox suspend noirq` e `th1520 mbox resume noirq` foram projetadas para salvar e restaurar registradores de máscara de interrupção no MBOX ICU0. No entanto, um array de tamanho incorreto usado para armazenar esses registradores levou à corrupção de memória ao acessar todos os quatro registradores.

Um problema corrigido no Kernel Linux envolve uma leitura fora dos limites na função `mtk hwlro get fdir entry()`. A variável `fsp->location`, que provém do usuário através da função `ethtool get rxnfc()`, não é devidamente validada, o que leva a uma potencial leitura fora dos limites. Este problema pode ser mitigado verificando a validade da variável `fsp->location` para prevenir tais leituras.

Uma vulnerabilidade no kernel Linux foi resolvida. O problema estava relacionado à função `visconti clk register gates()`, onde poderia ocorrer um estouro de array devido ao uso de -1 para representar a ausência de uma função de reset. Este valor foi armazenado em um inteiro sem sinal de 8 bits (`u8`), fazendo com que a condição `if (clks[i].rs id >= 0)` fosse sempre verdadeira, levando a um acesso fora dos limites.

Existe um problema de corrupção de memória devido à verificação de limites insuficiente na função `nci hci create pipe()`. A variável `pipe`, que é um valor `u8` proveniente da rede, pode causar corrupção de memória na função `nci hci connect gate()` se seu valor exceder 127.

O problema está relacionado a estouros de inteiros no componente ksmbd do kernel Linux em sistemas de 32 bits. Especificamente, as operações de adição na função `ipc msg alloc()` podem potencialmente causar estouro, levando à corrupção de memória. Para corrigir isso, foi adicionada uma verificação de limites usando `KSMBD IPC MAX PAYLOAD` para prevenir o estouro.

O problema está relacionado a um bug de estouro de inteiro no módulo binfmt flat do kernel Linux em sistemas de 32 bits. O bug ocorre ao calcular `full data` usando a fórmula `full data = data len + relocs * sizeof(unsigned long)`, o que poderia resultar em cálculos incorretos se a contagem de "relocs" não fosse verificada adequadamente. A maioria dos tamanhos e contagens é limitada a 256MB para prevenir estouros de inteiro, mas a contagem de "relocs" também precisa ser verificada.

The issue is related to an integer overflow in the Linux kernel, specifically in the `tps6594 rtc set offset()` function. The problem occurs when the `offset` variable, which is a long in the range (-277774)-277774, is multiplied by `TICKS PER HOUR`, a large number approximately equal to a hundred million. This multiplication can cause an overflow on 32-bit systems, where a long can hold numbers up to approximately two billion.

Uma vulnerabilidade de double free foi encontrada no módulo mtd: rawnand do kernel do Linux, especificamente na função `atmel pmecc create user()`. O problema ocorreu porque o ponteiro "user" foi alterado de ser alocado com `kzalloc()` para ser alocado por `devm kzalloc()`, e chamar `kfree(user)` levaria a um double free.

Foi identificado um bug do tipo “use-after-free” na função `register intc controller()`. O problema surge durante o tratamento de erros quando `d` é liberado sem ser removido de `intc list`, levando a uma situação de uso após liberação. Para resolver isso, a correção garante que `d` seja adicionado à lista somente após todas as operações terem sido concluídas com sucesso.

A questão envolve um problema de estouro de inteiro no componente RDMA/uverbs do kernel Linux. Especificamente, a expressão `cmd.wqe size * cmd.wr count` pode levar a um wrapping de inteiro, pois ambas as variáveis são valores u32 provenientes do usuário. Este resultado é então passado para `uverbs request next ptr()`, o que também poderia potencialmente sofrer wrapping. Além disso, a multiplicação `cmd.sge count * sizeof(struct ib uverbs sge)` pode sofrer estouro em sistemas de 32 bits. Para corrigir isso, a condição em `uverbs request next ptr()` foi reorganizada, e todos os chamadores foram modificados para utilizar `size mul()` nas multiplicações.

Um problema potencial no kernel Linux foi identificado, relacionado à função `msm ioctl gem submit()`. Especificamente, as variáveis `submit->cmd[i].size` e `submit->cmd[i].offset`, que são valores `u32` provenientes do usuário através da função `submit lookup cmds()`, podem levar a um estouro de inteiro. Isso é prevenido pelo uso da função `size add()` para evitar bugs de wrapping de inteiros.

O problema está relacionado à inicialização de variáveis anotadas com ` free()` no código de testes térmicos do kernel do Linux. Se uma função retornar antes que essas variáveis sejam atualizadas, a tentativa de liberar a memória para a qual elas apontam ao retornar da função pode causar uma falha no kernel. O problema foi corrigido em algumas partes do código de teste térmico.

O problema diz respeito a um estouro de inteiro na função `pagemap scan get args()` dentro do componente `fs/proc/task mmu` do kernel do Linux. A variável `arg->vec len`, um valor `u64` fornecido pelo usuário, é multiplicada por `sizeof(struct page region)`, o que pode levar a um estouro de inteiro. Para evitar isso, utiliza-se a função `size mul()`. Além disso, como as funções `size add/mul()` operam com valores long sem sinal, é essencial garantir que `arg->vec len` caiba em um long sem sinal para sistemas de 32 bits.

Foi identificado um possível problema de subfluxo de matriz no kernel do Linux, especificamente na função `ucsi ccg sync control()`. A variável `command` pode ser controlada pelo usuário via debugfs, o que representa um risco se `con index` for zero, podendo levar a um underflow de matriz. O problema ocorre ao acessar `&uc->ucsi->connector[con index - 1]`.

O problema está relacionado a um estouro de inteiro no componente svcrdma do kernel do Linux. Esse estouro pode ser desencadeado por um valor controlado pelo usuário, permitindo potencialmente que um invasor execute código arbitrário. O problema decorre de um commit no kernel do Linux que introduziu uma estrutura de dados “parsed chunk list”, levando a um aviso do verificador estático Smatch sobre um potencial estouro de sizeof controlado pelo usuário. A variável `segcount`, um u32 não confiável, é usada em um cálculo que pode causar um estouro de inteiro em sistemas de 32 bits, o que pode ser aceito por `xdr inline decode()`.

O problema está relacionado a um estouro de inteiro na função decode cb compound4res() do componente NFSD do kernel do Linux. Se o comprimento da tag for >= U32 MAX - 3, a adição de “comprimento + 4” pode resultar em um estouro de inteiro. Isso pode ser resolvido dividindo a decodificação em várias etapas, de modo que decode cb compound4res() não precise realizar operações aritméticas com o valor de comprimento inseguro. A vulnerabilidade pode ser explorada por um invasor remoto para executar código arbitrário.

O problema está relacionado a uma possível condição fora dos limites na função `ucsi ccg update set new cam cmd()`. A variável `*cmd` pode ser controlada pelo usuário via debugfs, permitindo que `new cam` chegue a 255, enquanto o tamanho da matriz `uc->updated[]` é `UCSI MAX ALTMODES` (30). A árvore de chamadas envolve várias funções, incluindo `ucsi cmd()`, `ucsi send command()`, `ucsi send command common()`, `ucsi run command()` e `ucsi ccg sync control()`. Isso poderia afetar a confidencialidade e a disponibilidade de informações protegidas.

O problema está relacionado a uma vulnerabilidade do tipo “use after free” no kernel do Linux, especificamente no módulo io edgeport. Essa vulnerabilidade pode ser explorada para comprometer a confidencialidade, a integridade e a disponibilidade das informações protegidas. O problema surge porque a função `dev dbg` é chamada após `usb free urb`, resultando em um uso após liberação do ponteiro `urb`. Para evitar esse problema, o ponteiro `dev` é armazenado no início da função.

Foi identificada uma possível vulnerabilidade de desreferência a NULL no kernel do Linux, especificamente no módulo wifi: cw1200. Esse problema foi descoberto por meio de análise estática após uma recente refatoração. A vulnerabilidade poderia ser potencialmente explorada, mas não foram fornecidos detalhes sobre dispositivos afetados ou incidentes reais.

Foi corrigida uma vulnerabilidade crítica no componente PCI keystone do kernel Linux. O problema envolvia a função `ks pcie quirk()`, na qual uma expressão da instrução `if` utilizava acidentalmente `&&` em vez de `||`, o que poderia resultar em uma desreferência a NULL. Esta correção altera a expressão da instrução if para usar a condição correta.