Gregkh

Ocorre uma gravação fora dos limites (out-of-bounds write) ao acionar o processamento HLINK BUMP em entradas de arquivo que possuem a flag `FLAG HLINKED` definida enquanto a opção de preservação de hard-link está inativa. Isso acontece porque o layout `file struct` carece do campo `F SUM`, permitindo o acesso à memória além da estrutura alocada e resultando na corrupção de dados adjacentes no heap ou na pilha.

Uma gravação fora dos limites do heap (heap out-of-bounds write) permite que atacantes remotos não autenticados gravem um byte controlado pelo atacante além do final de uma alocação de heap. Isso ocorre quando uma entrada files-from manipulada, contendo tanto uma barra invertida interna quanto uma final, é fornecida a um módulo de daemon rsync somente leitura, fazendo com que a função `add implied include()` subestime a barra invertida final ao dimensionar o buffer de destino.

Ocorre uma desreferenciação de ponteiro nulo no processo filho do daemon. Um invasor remoto pode causar a falha do daemon enviando uma lista de arquivos onde a primeira entrada é uma entrada de ponto não tipada como um diretório. O daemon processa a primeira entrada da lista de arquivos como um ponteiro de estrutura de diretório sem verificar o tipo da entrada, resultando em uma desreferenciação de ponteiro inválida ou não inicializada que encerra a conexão do cliente.

Existe um problema de escrita arbitrária de arquivos que permite que atacantes escrevam arquivos fora da árvore de destino pretendida. Isso ocorre ao especificar um caminho absoluto por meio das opções `--temp-dir` ou `--link-dest`, o que ignora a lógica de confinamento de renomeação. Isso permite que valores controlados pelo atacante escrevam arquivos em qualquer local acessível ao processo rsync.

Existe uma condição de corrida de link simbólico (symlink race condition) que permite a um invasor local fazer com que o software aplique Listas de Controle de Acesso (ACLs) ou atributos estendidos arbitrários a arquivos indesejados. Isso ocorre quando um link simbólico é substituído em um caminho de destino previsível entre a operação de gravação do arquivo e as chamadas subsequentes das funções `acl set file()` ou `lsetxattr()`. Ao explorar essa janela de tempo, um invasor pode redirecionar a aplicação de ACLs e atributos estendidos para arquivos fora da árvore de destino pretendida, o que pode resultar em permissões elevadas e escalonamento de privilégios locais.

Uma falha de validação de certificado TLS permite que atacantes on-path interceptem sessões criptografadas ao apresentar certificados autossinados ou inválidos. Isso ocorre porque o software falha ao validar os certificados TLS do servidor em relação a uma Autoridade Certificadora (CA) confiável ou ao verificar a correspondência do hostname do certificado. Consequentemente, um atacante pode descriptografar ou adulterar o conteúdo da sessão sem que o cliente detecte a interferência.

Existe uma gravação fora dos limites na função `read args()`. Um remetente mal-intencionado pode corromper a memória heap adjacente ao enviar uma lista de argumentos manipulada. Isso ocorre quando a contagem de argumentos preenche a alocação `argv` exatamente, fazendo com que o terminador NULL final seja gravado além do limite da alocação.

Existe uma gravação fora dos limites (out-of-bounds write) na função `parse size arg()`. O problema ocorre porque o valor de retorno de `snprintf()` é utilizado diretamente como um índice em um array do segmento .bss sem a devida verificação de limites. Quando o `snprintf()` trunca a string de tamanho formatada, o valor retornado corresponde ao número de caracteres que teriam sido gravados, incluindo a parte truncada, e esse valor pode exceder o comprimento do array. A gravação indexada subsequente atinge a memória fora dos limites pretendidos, corrompendo a memória .bss (um segmento de memória usado para variáveis globais e estáticas não inicializadas).

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.

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 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.

Um problema de Use-After-Free (UAF) existe no driver ALSA loopback. A função `loopback check format()` pode interromper o lado de captura quando a reprodução inicia com parâmetros que não coincidem com um fluxo de captura em execução. Embora a busca por pares seja realizada sob o `cable->lock`, a função `snd pcm stop()` é executada após a liberação do lock. Uma operação de fechamento simultânea pode remover a entrada de captura de `cable->streams[]` e liberar seu runtime enquanto o caminho de gatilho de reprodução ainda mantém um ponteiro de substream de par obsoleto.

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`.

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.

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.

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`.