Guido Vranken

Um problema de double-free existe na função `parse def()` em `src/conf.c`. Isso ocorre quando o sistema analisa blocos de configuração compostos ou de array aninhados e falha ao verificar os valores de retorno antes de prosseguir. Consequentemente, a função `snd config delete()` é chamada duas vezes no mesmo nó já liberado, o que pode levar à corrupção de memória, uma gravação de ponteiro NULL ou uma leitura de memória inválida se um invasor fornecer um texto de configuração ALSA maliciosamente elaborado.

Um servidor malicioso pode explorar o TLS OCSP stapling ao entregar uma resposta manipulada através da extensão `status request`. Isso desencadeia um double-free no caminho de verificação de certificado do cliente quando a resposta stapled é verificada. Um double-free ocorre quando um programa tenta liberar o mesmo local de memória duas vezes, o que pode corromper a memória heap. Isso pode levar a uma Negação de Serviço (DoS), execução de código controlada pelo invasor ou outro comportamento indefinido. O OCSP stapling não está habilitado por padrão.

Ocorre uma falha de asserção durante o processo de verificação de assinatura ECDSA (Elliptic Curve Digital Signature Algorithm).

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

A função `CombinedMult` no pacote `ecc/p384` (curva secp384r1) calcula um valor incorreto para determinadas entradas. Este problema não afeta as operações ECDH e de assinatura ECDSA que dependem desta curva. O problema é resolvido implementando fórmulas de adição completas.

A função `html.Parse` apresenta complexidade de análise quadrática ao lidar com entradas específicas. Isso pode resultar em negação de serviço (DoS) caso um atacante envie conteúdo HTML maliciosamente elaborado.

A função `html.Parse` pode entrar em um loop infinito de análise ao processar entradas HTML específicas. Isso pode resultar em uma negação de serviço (DoS) se um atacante fornecer conteúdo HTML especialmente criado.

O problema está relacionado ao consumo descontrolado de recursos na linguagem de programação Golang. Um invasor pode criar uma entrada para as funções `Parse` que seria processada de forma não linear em relação ao seu comprimento, resultando em uma análise extremamente lenta. Isso poderia causar uma negação de serviço. O número estimado de dispositivos potencialmente afetados em todo o mundo não está disponível. Não há informações sobre incidentes reais em que essa vulnerabilidade tenha sido explorada.

O problema decorre do tratamento de strings de entrada manipuladas pela função `idna.encode()`, o que pode levar a uma complexidade quadrática e, consequentemente, a uma condição de negação de serviço. Isso é desencadeado por uma entrada manipulada que faz com que a função `idna.encode()` processe a entrada com uma carga computacional considerável, aumentando significativamente o tempo de processamento de forma quadrática em relação ao tamanho da entrada. A vulnerabilidade pode permitir que um invasor remoto cause uma negação de serviço.

The issue is related to the ScalarMult and ScalarBaseMult methods of the P256 Curve in the Go programming language, which may return incorrect results when called with specific unreduced scalars. This could potentially allow a remote attacker to impact the integrity of protected information. The issue does not affect usages of crypto/ecdsa or crypto/ecdh.

The issue concerns the multiplication of certain unreduced P-256 scalars, which can produce incorrect results. However, there are no known protocols that can be attacked due to this issue. The problem arises because the P-256 assembly does not use complete addition formulas, which can lead to incorrect results when the two inputs are equal. This was previously mitigated by always reducing the scalar, but a change in the math/big rewrite removed this reduction, assuming it was not necessary.

A vulnerabilidade permite que invasores remotos provoquem uma negação de serviço (panic) por meio de um cabeçalho de grande tamanho enviado para `ReadRequest` ou `ReadResponse`. O servidor, o transporte e o cliente podem ser afetados em algumas configurações. Um servidor ou cliente HTTP malicioso pode fazer com que o cliente ou servidor net/http entre em estado de panic. `ReadRequest` e `ReadResponse` podem entrar em um estado de panic irrecuperável ao ler um cabeçalho muito grande.

**Nome do software vulnerável e versões afetadas: Versões da glibc anteriores à 2.32 Descrição: O problema está relacionado às funções cosl, sinl, sincosl e tanl da Biblioteca C do GNU (glibc), que podem causar um estouro de buffer. Isso pode levar a uma negação de serviço ao danificar a pilha ao chamar funções trigonométricas com um argumento pseudo-zero. Especificamente, o problema ocorre quando uma entrada para uma função long double de 80 bits contém um padrão de bits não canônico, como passar um valor 0x5d414141414141410000 para sinl em alvos x86. Recomendações: Para versões da glibc anteriores à 2.32, atualize para a versão 2.32 ou posterior para resolver o problema. Como solução temporária, considere restringir o uso das funções vulneráveis cosl, sinl, sincosl e tanl até que um patch esteja disponível. Evite usar padrões de bits não canônicos como entrada para essas funções a fim de minimizar o risco de exploração.

Foi detectada uma falha devido a um gerenciamento incorreto do buffer, permitindo que um cliente remoto provoque um estouro de buffer em uma instância do Squid atuando como proxy reverso. Isso pode afetar a confidencialidade, a integridade e a disponibilidade das informações protegidas.

Um bug no fork do gerenciador de pacotes opkg impede a análise correta das somas de verificação incorporadas no índice do repositório assinado, permitindo que um invasor do tipo man-in-the-middle injete cargas de pacotes arbitrárias, que são instaladas sem verificação. Este problema está relacionado a uma falha no código que verifica as somas de verificação SHA-256 presentes no índice de assinatura digital dos pacotes, permitindo que um invasor crie condições nas quais essas somas de verificação sejam ignoradas, contornando assim os mecanismos de verificação de integridade dos recursos ipk baixados.

The issue is related to a buffer overflow due to unbounded copying of user input. This could allow a remote attacker to access sensitive data, compromise its integrity, and potentially cause a denial of service. An attacker may also be able to execute arbitrary code or cause the application to crash by writing past the end of a buffer stored on the stack.

The issue is related to the `django.utils.text.Truncator` class, specifically the `chars()` and `words()` methods. When these methods are passed the `html=True` argument, they can be extremely slow to evaluate certain inputs due to a catastrophic backtracking vulnerability in a regular expression. This vulnerability can be exploited to cause a denial of service. The `chars()` and `words()` methods are used to implement the `truncatechars html` and `truncatewords html` template filters.

The issue is related to the HTMLParser function in django.utils.html.strip tags, which can be slow to evaluate large input sequences containing incomplete HTML entities. This can be exploited by a remote attacker to cause a denial of service.

The issue allows certain input files to cause the code to enter an infinite loop when parsed, potentially leading to a Denial of Service (DoS) attack.

The issue allows certain input files to cause the code to hang when parsed, potentially leading to a denial-of-service (DoS) attack. Note that Apache Sanselan was later renamed to Apache Commons Imaging.