Marten-Seemann

**Nome do Software Vulnerável e Versões Afetadas** quic-go (versões afetadas não especificadas) **Description** Um invasor pode causar a alocação excessiva de memória nas implementações de cliente e servidor HTTP/3 ao enviar um quadro HEADERS codificado em QPACK. Este quadro é decodificado em uma seção de trailer de campo grande, contendo inúmeros nomes de campos exclusivos ou valores extensos. O sistema constrói um `http.Header` para o `http.Request` ou `http.Response`, mas impõe limites apenas ao tamanho do quadro HEADERS compactado, e não à seção de campo decodificada. Essa discrepância permite que um quadro maliciosamente elaborado se expanda até 50 vezes seu tamanho codificado usando entradas de tabela estática QPACK, levando à exaustão de memória e a um estado de negação de serviço (DoS). **Recommendations** No momento, não há informações sobre uma versão mais recente que contenha a correção para esta vulnerabilidade.

**Name of the Vulnerable Software and Affected Versions** webtransport-go versions prior to 0.10.0 **Description** An attacker can cause unbounded memory consumption by repeatedly creating and closing many WebTransport streams. Closed streams were not removed from an internal session map, preventing garbage collection of their resources. A malicious peer can exploit this by opening and closing a large number of streams, leading to continuous memory growth proportional to the number of closed streams. The software maintains an internal map tracking WebTransport streams, and affected versions did not remove entries for closed streams from this map. **Recommendations** Update to version 0.10.0 or later.

**Name of the Vulnerable Software and Affected Versions** webtransport-go versions prior to 0.10.0 **Description** A malicious peer can cause a denial of service in webtransport-go by preventing or indefinitely delaying WebTransport session closure. Specifically, a peer can withhold QUIC flow control credit on the CONNECT stream, blocking transmission of the WT CLOSE SESSION capsule and causing the close operation to hang. The WebTransport protocol signals session termination by sending a WT CLOSE SESSION capsule on the CONNECT stream. Affected versions blocked indefinitely while waiting for sufficient QUIC flow control credit from the peer. **Recommendations** Update to version 0.10.0 or later.

**Name of the Vulnerable Software and Affected Versions** webtransport-go versions 0.3.0 through 0.9.0 **Description** webtransport-go’s session implementation is susceptible to excessive memory consumption. An attacker can send a `WT CLOSE SESSION` capsule containing an excessively large Application Error Message. The implementation does not enforce the draft-mandated 1024-byte limit on this field, allowing an attacker to send an arbitrarily large message payload that is fully read and stored in memory. This allows an attacker to consume an arbitrary amount of memory, requiring the full payload transmission to achieve the memory consumption. **Recommendations** Upgrade to version 10.0.0 or later.

**Nome do Software Vulnerável e Versões Afetadas** versões do quic-go 0.50.0 **Descrição** A lógica de recuperação de perda para pacotes de sondagem de caminho no quic-go pode ser explorada por um cliente QUIC malicioso para provocar um desreferenciamento de ponteiro nulo. Isso é conseguido enviando pacotes QUIC válidos de diferentes endereços remotos, acionando a lógica de validação de caminho e fazendo com que o servidor envie pacotes de sondagem de caminho, seguido pelo envio de ACKs especificamente construídos para os pacotes recebidos do servidor. **Recomendações** Para a versão 0.50.0 do quic-go, atualize para a versão 0.50.1, que contém um patch que corrige a vulnerabilidade.

Nome do software vulnerável e versões afetadas: versões do quic-go anteriores à 0.48.2 Descrição: Um invasor fora do caminho pode injetar um pacote ICMP “Packet Too Large”, interrompendo uma conexão QUIC ao definir o valor de MTU para menos de 1200 bytes. Isso pode ser feito após a conclusão do handshake, contornando qualquer fallback de TCP. O invasor precisa conhecer o endereço IP e a porta do cliente para realizar o ataque. Recomendações: Para versões anteriores à 0.48.2, atualize para a versão 0.48.2 para corrigir a vulnerabilidade. Como solução temporária, considere usar `IP PMTUDISC PROBE` em vez de `IP PMTUDISC DO` para desativar o rastreamento de MTU do kernel. Como alternativa, use o iptables para descartar pacotes ICMP “Unreachable” (inacessível) para minimizar o risco de exploração.

**Nome do software vulnerável e versões afetadas** Versões do quic-go anteriores à 0.42.0 **Descrição** O problema está relacionado à implementação do protocolo QUIC no quic-go, onde um invasor pode fazer com que o seu par fique sem memória enviando um grande número de quadros `NEW CONNECTION ID` que retiram IDs de conexão antigas. O receptor deve responder a cada quadro de aposentadoria com um quadro `RETIRE CONNECTION ID`. No entanto, o invasor pode impedir que o receptor envie esses quadros `RETIRE CONNECTION ID` colapsando a janela de congestionamento do par e manipulando a estimativa de RTT do par. **Recomendações** Para versões do quic-go anteriores à 0.42.0, atualize para a versão 0.42.0 ou posterior para resolver o problema. Como solução temporária, considere restringir o uso de quadros `NEW CONNECTION ID` até que um patch esteja disponível. Evite usar o quadro `NEW CONNECTION ID` no endpoint da API afetado até que o problema seja resolvido.

**Nome do software vulnerável e versões afetadas** Versões do Quiche anteriores à 0.19.2 Versões do Quiche anteriores à 0.20.1 **Descrição** O problema está relacionado ao armazenamento ilimitado de informações relacionadas à aposentadoria de IDs de conexão, o que pode levar ao consumo excessivo de recursos. Cada conexão QUIC possui um conjunto de identificadores de conexão (IDs). Os terminais declaram o número de IDs de conexão ativas que estão dispostos a suportar usando o parâmetro de transporte `active connection id limit`. O par pode criar novos IDs usando um quadro “NEW CONNECTION ID”, mas deve permanecer dentro do limite de IDs ativos. Isso é feito por meio da aposentadoria de IDs antigos: o terminal envia um ‘NEW CONNECTION ID’ que inclui um valor no campo `retire prior to`, o que gera um quadro “RETIRE CONNECTION ID” como confirmação. Um invasor remoto não autenticado pode explorar a vulnerabilidade enviando quadros “NEW CONNECTION ID” e manipulando a conexão de modo que os quadros “RETIRE CONNECTION ID” só possam ser enviados a uma taxa mais lenta do que a de recebimento, levando ao armazenamento de informações relacionadas a IDs de conexão em uma fila ilimitada. **Recomendações** Para versões anteriores à 0.19.2, atualize para a versão 0.19.2 ou posterior. Para versões anteriores à 0.20.1, atualize para a versão 0.20.1 ou posterior. Como solução temporária, considere restringir o tamanho da janela de congestionamento do par para minimizar o risco de exploração. Evite usar o campo `retire prior to` no quadro “NEW CONNECTION ID” até que o problema seja resolvido.

**Nome do software vulnerável e versões afetadas** Versões do quic-go anteriores à 0.37.7 Versões do quic-go anteriores à 0.38.2 Versões do quic-go anteriores à 0.39.4 **Descrição** Um invasor pode fazer com que seu par fique sem memória enviando um grande número de quadros `PATH CHALLENGE`. O destinatário deve responder a cada quadro `PATH CHALLENGE` com um quadro `PATH RESPONSE`. No entanto, o invasor pode impedir que o destinatário envie a maioria desses quadros `PATH RESPONSE` colapsando a janela de congestionamento do par e manipulando a estimativa de RTT do par. **Recomendações** Para versões anteriores à 0.37.7, atualize para a versão 0.37.7 ou posterior. Para versões anteriores à 0.38.2, atualize para a versão 0.38.2 ou posterior. Para versões anteriores à 0.39.4, atualize para a versão 0.39.4 ou posterior.

**Name of the Vulnerable Software and Affected Versions** quiche versions 0.15.0 through 0.19.0 **Description** The issue is related to unbounded queuing of path validation messages, which could lead to excessive resource consumption. QUIC path validation requires that the recipient of a `PATH CHALLENGE` frame responds by sending a `PATH RESPONSE`. An unauthenticated remote attacker can exploit this by sending `PATH CHALLENGE` frames and manipulating the connection, such as restricting the peer's congestion window size, so that `PATH RESPONSE` frames can only be sent at a slower rate than they are received, leading to storage of path validation data in an unbounded queue. **Recommendations** For quiche versions 0.15.0 through 0.19.0, update to a version greater than 0.19.0 to address this problem. As a temporary workaround, consider restricting access to the `PATH CHALLENGE` frame to minimize the risk of exploitation. Avoid manipulating the connection to restrict the peer's congestion window size, which can exacerbate the issue.

**Name of the Vulnerable Software and Affected Versions** h2o versions 2.3.0-beta and prior **Description** The QUIC stack, as used by h2o, is susceptible to a state exhaustion attack. When h2o is serving HTTP/3, a remote attacker can exploit this vulnerability to progressively increase the memory retained by the QUIC stack. This can eventually cause h2o to abort due to memory exhaustion. HTTP/1 and HTTP/2 are not affected by this vulnerability as they do not use QUIC. **Recommendations** For versions 2.3.0-beta and prior, consider disabling HTTP/3 support as a temporary workaround to mitigate the issue. Update to a version that includes the fix committed in d67e81d03be12a9d53dc8271af6530f40164cd35 to fully resolve the issue.

**Name of the Vulnerable Software and Affected Versions** quic-go versions 0.37.0 through 0.37.2 **Description** The issue arises from serializing an ACK frame after the CRYPTO frame, allowing a node to complete the handshake. This can trigger a nil pointer dereference when the node attempts to drop the Handshake packet number space, leading to a panic. An attacker can bring down a quic-go node with minimal effort by completing the QUIC handshake, which requires sending and receiving only a few packets. **Recommendations** For quic-go versions 0.37.0 through 0.37.2, update to version 0.37.3 to resolve the issue. As a temporary workaround, consider restricting access to the QUIC handshake protocol until the patch is applied.

**Name of the Vulnerable Software and Affected Versions** go-libp2p versions prior to 0.27.4 go-libp2p versions prior to 0.30.0 **Description** A malicious actor can store an arbitrary amount of data in a remote node's memory by sending the node a message with a signed peer record. This memory does not get garbage collected, and so the victim can run out of memory and crash. If users of go-libp2p in production are not monitoring memory consumption over time, it could be a silent attack, where the attacker could bring down nodes over a period of time, depending on the node resources. For example, a go-libp2p node on a virtual server with 4 GB of memory can be brought down in about 90 seconds. **Recommendations** For go-libp2p versions prior to 0.27.4, update to version 0.27.4 or later to resolve the issue. For users who want to stay on the 0.27.x release, update to go-libp2p version 0.27.7. For the latest release, update to go-libp2p version 0.30.0. As a temporary workaround, consider monitoring memory consumption closely to detect potential attacks.

**Name of the Vulnerable Software and Affected Versions** go-libp2p versions prior to 0.27.8 go-libp2p versions prior to 0.28.2 go-libp2p versions prior to 0.29.1 **Description** A malicious peer can use large RSA keys to run a resource exhaustion attack and force a node to spend time doing signature verification of the large key. This issue is present in the core/crypto module of go-libp2p and can occur during the Noise handshake and the libp2p x509 extension verification step. To prevent this attack, go-libp2p now restricts RSA keys to <= 8192 bits. **Recommendations** For go-libp2p versions prior to 0.27.8, update to version 0.27.8 or later and use the updated Go compiler in 1.20.7 or 1.19.12. For go-libp2p versions prior to 0.28.2, update to version 0.28.2 or later and use the updated Go compiler in 1.20.7 or 1.19.12. For go-libp2p versions prior to 0.29.1, update to version 0.29.1 or later and use the updated Go compiler in 1.20.7 or 1.19.12. As a temporary workaround is not available, updating to the specified patch releases is necessary to protect against this issue.