Brian Carpenter

Um problema de escalonamento de privilégios existe no componente de Prevenção de Perda de Dados (Data Loss Prevention).

O processamento de conteúdo web maliciosamente manipulado pode levar a um travamento inesperado do processo devido ao manuseio inadequado da memória.

Ocorre uma desreferência de ponteiro NULL quando uma célula CERT é recebida fora de ordem. Uma desreferência de ponteiro NULL é um erro de tempo de execução que acontece quando um programa tenta ler ou escrever em um endereço de memória que é NULL, frequentemente levando ao travamento do sistema.

Uma leitura fora dos limites (out-of-bounds read) de um byte pode ocorrer ao processar uma célula BEGIN malformada.

O Tor manipula incorretamente a contabilização da fila de ordem incorreta (out-of-order queue) do conflux durante o processo de limpeza de uma fila.

Uma falha no cliente pode ocorrer quando existe pressão de memória na fila de circuitos devido ao fechamento duplo de um circuito.

Ocorre uma leitura fora dos limites (out-of-bounds read) durante o processamento do payload de células quando uma célula END, TRUNCATE ou TRUNCATED não possui um motivo em seu payload.

**Nome do software vulnerável e versões afetadas: Versões do Firefox anteriores à 86 Descrição: A página de desenvolvedor about:memory possui uma função Measure para explorar quais tipos de objetos o navegador alocou e seus tamanhos. Quando essa função era invocada, o navegador chamava incorretamente a função sizeof, em vez de usar o método da API que verifica se há ponteiros inválidos. Recomendações: Para versões anteriores à 86, atualize para a versão 86 ou posterior para resolver o problema. Como solução temporária, considere evitar o uso da função Measure na página about:memory até que a atualização seja aplicada.

O problema decorre do ciclo de vida dos atores IPC, em que os atores gerenciados podem permanecer ativos após o encerramento de seus atores gerenciadores. Nesses casos, os atores gerenciados devem garantir que não tentem utilizar um ator inativo ao qual tenham uma referência. No entanto, uma verificação para isso foi omitida no WebGL, resultando em um uso após liberação de memória (use-after-free) e uma falha potencialmente explorável.

**Nome do software vulnerável e versões afetadas: Versões do Firefox anteriores à 81 Descrição: O problema está relacionado ao processamento de superfícies, em que o tempo de vida pode exceder o de um buffer persistente, levando à corrupção de memória e a uma falha potencialmente explorável. Também está associado a uma vulnerabilidade no componente WebGL que envolve a cópia de um buffer sem verificar o tamanho dos dados de entrada, permitindo potencialmente que um invasor remoto execute código arbitrário. Recomendações: Para versões anteriores à 81, atualize para a versão 81 ou posterior para resolver o problema. Como solução temporária, considere desativar o componente WebGL até que um patch esteja disponível. Restrinja o acesso a páginas da Web potencialmente vulneráveis para minimizar o risco de exploração.

Uma falha de uso após liberação (use-after-free) no gerenciador de cotas pode ocorrer ao remover dados sobre uma origem cuja guia foi fechada recentemente, podendo levar a uma falha explorável. A falha está relacionada a um problema de gerenciamento de memória, em que a memória é acessada após ter sido liberada. Isso poderia permitir que um invasor remoto executasse código arbitrário.

A cross-site scripting (XSS) issue exists in the View Filters page and Edit Filter page, allowing remote attackers to inject arbitrary code through a crafted PATH INFO, provided that the Content Security Policy (CSP) settings permit it.

The issue is related to a heap out-of-bounds read in the code handling the end-of-response for SMTP. This occurs when the buffer passed to `smtp endofresp()` is not null terminated and contains no character ending the parsed number, and `len` is set to 5. As a result, the `strtol()` call reads beyond the allocated buffer, but the read contents are not returned to the caller. The exploitation of this issue may allow a remote attacker to impact the confidentiality, integrity, and availability of protected information, potentially leading to a denial of service.

A heap use-after-free flaw was found in the code related to closing an easy handle. When closing and cleaning up an 'easy' handle in the `Curl close()` function, the library code first frees a struct (without nulling the pointer) and might then subsequently erroneously write to a struct field within that already freed struct.

The issue is related to a heap-based buffer over-read in the `voutf()` function, which may result in information exposure and denial of service. This occurs due to flawed wrap logic when displaying warning and informational messages to stderr, causing the buffer arithmetic to calculate the remainder wrong and end up reading behind the end of the buffer. This could lead to information disclosure or crash, potentially resulting in a security issue if used in certain situations, such as a server using the curl command line to run something and showing stderr to the user, where user input can trigger the crash and disclose user memory contents.

The issue allows context-dependent attackers to cause a denial of service, resulting in a floating point exception and crash, via a crafted cert8.db file. This is due to a problem in the ` hash open` function in hash.c.

The issue arises when an IMAP FETCH response line indicates that the returned data is zero bytes. In this case, libcurl passes on the non-existing data with a pointer and the size (zero) to the deliver-data function. This function treats zero as a magic number and invokes strlen() on the data to figure out the length. However, the strlen() is called on a heap-based buffer that might not be zero-terminated, which can cause libcurl to read beyond the end of the buffer into adjacent memory or crash. As a result, libcurl may deliver the incorrectly read data to the application as if it were actually downloaded.

The issue is related to a buffer over-read in the PPP parser, specifically in the handle mlppp() function within print-ppp.c.

The issue is related to a buffer over-read in the DECnet parser. A remote attacker could obtain sensitive information by sending a specially crafted request to exploit this issue in the HNCP component.

A double free vulnerability exists in the zip dirent read function in zip dirent.c, which may allow attackers to have an unspecified impact. The vectors by which this issue can be exploited are unknown.