Loïc Hoguin

Um peer remoto não autenticado pode causar exaustão de memória em um endpoint HTTP/2. O problema ocorre porque a função `cow http2 machine:headers decode/4` em `src/cow http2 machine.erl` utiliza `cow hpack:decode/3` para decodificar blocos HEADERS sem impor um limite ao tamanho da lista de cabeçalhos decodificada, ignorando o `SETTINGS MAX HEADER LIST SIZE` definido na RFC 9113. Um invasor pode armazenar um valor de cabeçalho grande (até 4096 bytes) na tabela dinâmica e referenciá-lo várias vezes usando campos indexados de um byte. Isso permite que uma pequena quantidade de tráfego de rede se expanda em uma grande alocação de memória. Por exemplo, um bloco de 110 bytes pode ser decodificado em uma lista de cabeçalhos de aproximadamente 390 KB. Quando um consumidor, como o Cowboy usando `cowboy http2:headers to map/2`, junta campos `cookie` repetidos em um único binário, ele aloca esse tamanho expandido para cada stream, podendo levar a VM Erlang ao esgotamento de memória.

A codificação ou escape inadequado de saída na função `cow link:link/1` permite o contrabando de diretivas do cabeçalho Link. A função `cow link:do link/1` interpola a URI de destino, o valor `rel` e as chaves de atributo diretamente no valor do cabeçalho Link serializado sem escape ou validação de gramática de token. Especificamente, um byte `>` no destino pode fechar prematuramente o slot da URI, permitindo a adição de entradas de link não autorizadas. Além disso, um `"` ou `` no valor `rel` pode escapar a string entre aspas para abrir novos parâmetros, e qualquer byte em uma chave de atributo é emitido literalmente. Isso pode forçar os navegadores a fazer conexões fora de banda para origens controladas por atacantes por meio de diretivas como `rel="preconnect"`, `rel="preload"` e `rel="prerender"`.

Um peer remoto não autenticado de HTTP/2 ou HTTP/3 pode causar a negação de serviço ao esgotar a memória em um servidor ou cliente. O problema reside no decodificador de inteiros prefixados HPACK e QPACK `cow hpack common:dec big int/3` (invocado a partir de `cow hpack:decode/2` e `cow qpack:decode field section/3`), que não impõe limites ao número de octetos de continuação, à largura de bits resultante ou ao valor final. Como os inteiros Erlang são imutáveis, cada atualização aloca um novo bignum, resultando em uma alocação de memória transitória que cresce quadraticamente em relação ao comprimento codificado. Uma única representação indexada HPACK máxima dentro de frames HTTP/2 HEADERS e CONTINUATION pode disparar centenas de megabytes de alocação e rotatividade de coleta de lixo, potencialmente levando ao esgotamento da memória da VM Erlang quando conexões repetidas ou simultâneas são utilizadas.

Um invasor remoto não autenticado pode esgotar a memória do processo de conexão via HTTP/1.1. O manipulador HTTP/1.1 em `cowboy http` impõe o limite `max headers` contando nomes de cabeçalhos distintos. Se uma solicitação contiver várias linhas de cabeçalho com o mesmo nome, os valores são concatenados em um único binário sob uma única chave de mapa, impedindo que o limite `max headers` seja atingido. Como não há limite para o número total de linhas de cabeçalho ou para o tamanho total em bytes do bloco de cabeçalho, um invasor pode enviar inúmeras linhas de cabeçalho com o mesmo nome para aumentar a memória binária do processo de conexão. Se o `max heap size` não estiver configurado, isso pode levar a condições de falta de memória (out-of-memory) na VM Erlang.

A neutralização inadequada de sequências CRLF em cabeçalhos HTTP permite a divisão de resposta HTTP (HTTP response splitting) por meio de bytes não-VCHAR em valores de string de campos estruturados. A função `escape string/2` em `cow http struct hd` escapa apenas barras invertidas e aspas duplas, transmitindo outros bytes literalmente. Isso cria uma assimetria onde o parser aceita apenas ASCII imprimível, mas o codificador emite qualquer byte, incluindo Carriage Return (CR) e Line Feed (LF). Uma aplicação que constrói um cabeçalho HTTP estruturado via `item/1` em `cow http struct hd` (ou wrappers como `wt protocol/1` em `cow http hd`) usando entrada controlada por um atacante pode ter sequências CRLF injetadas. Essas sequências encerram o cabeçalho atual, fazendo com que os bytes subsequentes sejam interpretados como um novo cabeçalho.

O Consumo Não Controlado de Recursos no módulo `gun http` permite que um servidor malicioso esgote a memória do cliente por meio do buffer de resposta HTTP/1.1 ilimitado. Na função `handle()/5`, três cláusulas acumulam dados TCP recebidos no buffer da conexão usando concatenação binária sem verificação de limite superior. Especificamente, a cláusula head anexa dados até que o terminador de cabeçalho seja encontrado, a cláusula `body chunked` anexa dados quando `cow http te:stream chunked()/2` indica um limite de chunk incompleto, e a cláusula `body trailer` anexa dados até que o terminador final seja encontrado. Se o terminador esperado nunca chegar, o binário cresce indefinidamente no estado. Um servidor malicioso pode explorar isso enviando uma resposta parcial que nunca termina, levando ao crescimento ilimitado do heap. Como o BEAM não impõe limites de heap por processo por padrão, uma única conexão pode esgotar toda a memória disponível no nó, resultando em um travamento de falta de memória (out-of-memory) em todo o nó.

Um problema no módulo `gun http` permite que um servidor HTTP malicioso force um cliente para o modo de protocolo bruto (raw protocol mode) ao enviar uma resposta 101 Switching Protocols não solicitada. Na função `handle inform/8`, o software verifica a sintaxe do cabeçalho Upgrade e a referência do fluxo, mas não verifica se o cliente realmente solicitou um upgrade através dos cabeçalhos Upgrade ou Connection: upgrade. Consequentemente, qualquer resposta 101 dispara uma mensagem `gun upgrade` e transita a conexão para o modo de protocolo bruto. Neste modo, o `gun raw` desativa o controle de fluxo e rearma o modo ativo do socket após cada pacote, permitindo que um servidor inunde o cliente com bytes arbitrários. Estes são encaminhados como mensagens `gun data` ilimitadas, o que pode esgotar a caixa de correio do processo proprietário e a memória BEAM, levando ao travamento da máquina virtual.

Um erro de validação de origem no módulo `gun http2` permite a injeção de cookies de origem cruzada (cross-origin) por meio de uma autoridade HTTP/2 PUSH PROMISE não validada. Na função `push promise frame()`, o pseudo-cabeçalho `:authority` de um frame PUSH PROMISE recebido é armazenado no registro de stream prometido sem verificar se ele corresponde à origem da conexão. Posteriormente, a função `headers frame()` chama a `set cookie header()` utilizando essa autoridade não validada. Este comportamento viola os padrões de protocolo que exigem que os receptores tratem pushes de recursos para os quais o servidor não é autoritativo como erros de protocolo. Um servidor HTTP/2 malicioso ou comprometido pode usar isso para implantar cookies de domínios de terceiros arbitrários no armazenamento de cookies compartilhado do cliente, podendo levar a ataques de fixação de sessão ou sequestro de conta. Isso é explorável quando o software está configurado com um `cookie store` e se conecta a um servidor HTTP/2 com server push habilitado.

O manuseio inadequado de dados altamente compactados leva à amplificação de dados, permitindo que um ator remoto não autenticado cause uma negação de serviço via exaustão de memória. A função `cow spdy:inflate/2` passa bytes compactados de um peer para `zlib:inflate/2` sem um limite de tamanho de saída. Como o dicionário de compressão de cabeçalho SPDY (`?ZDICT`) é público e o zlib pode compactar bytes repetidos em uma proporção de aproximadamente 1024:1, um pequeno payload de quadro SPDY pode ser descompactado em gigabytes no heap do BEAM, resultando em uma condição de falta de memória (OOM) que derruba o nó. Esta condição pode ser disparada por um único quadro SPDY não autenticado. A função `cow spdy:parse headers/2` afeta os analisadores dos tipos de quadro `syn stream`, `syn reply` e `headers`. Este problema impacta especificamente aplicações que utilizam `cow spdy:parse/2` para analisar quadros SPDY de peers não confiáveis.

Um problema na análise de cabeçalhos multipart permite que um invasor não autenticado cause uma negação de serviço por meio do acúmulo ilimitado de buffer. A função `read part()` em `src/cowboy req.erl` acumula bytes de requisição recebidos em um binário Buffer sem uma verificação de limite superior. Quando a função `parse headers()` retorna mais dados, a função continua a ler e recursar com um buffer ampliado. Ao enviar uma requisição `multipart/form-data` que nunca fornece uma seção de cabeçalho completa — como aquela que não contém o delimitador de limite ou a sequência ` ` — um invasor pode forçar o servidor a acumular memória linearmente, potencialmente esgotando a memória BEAM com alguns uploads simultâneos. Isso ocorre quando um endpoint HTTP chama `read part/1,2` para processar corpos de requisição.

A Neutralização Imprópria de Sequências CRLF (Injeção de CRLF) permite a divisão e injeção de eventos SSE por meio de valores de campo não validados. A função `cow sse:event/1` protege os campos `id` e `event` contra ` `, mas não contra `r`, e a função interna `prefix lines/2`, utilizada para campos de dados e comentários, realiza a divisão apenas em ` `. Como a especificação SSE exige que os decodificadores tratem `r `, `r` e ` ` como terminadores de linha equivalentes, um invasor que controle qualquer um desses campos pode injetar linhas SSE adicionais e forjar um evento completo com um tipo de evento e carga de dados arbitrários no receptor. Em implantações típicas onde clientes EventSource de navegadores ou outros consumidores de SSE despacham em `event.type` e renderizam `event.data`, isso permite a divisão de eventos, manipulação de lógica no lado do cliente e comportamento equivalente a XSS armazenada quando os dados do evento são inseridos no DOM.

Um problema de consumo descontrolado de recursos no módulo `cow http te` permite a alocação excessiva. O analisador de codificação de transferência fragmentada (chunked transfer-encoding) aceita um número ilimitado de dígitos hexadecimais no campo de tamanho do fragmento. Cada dígito dispara uma multiplicação de bignum, resultando em trabalho de CPU O(N²) e uso de memória O(N) para N dígitos hexadecimais. Quando a entrada é fornecida em gotas (drip-fed), o analisador descarta o comprimento acumulado em leituras parciais e reinicia, aumentando o custo para O(N³). Um invasor remoto não autenticado pode causar a negação de serviço via exaustão de CPU e amplificação de memória enviando uma solicitação HTTP/1.1 com `Transfer-Encoding: chunked` e uma string hexadecimal de tamanho de fragmento excessivamente longa. Este problema está associado ao arquivo `src/cow http te.erl` e às funções `cow http te:stream chunked/2` e `cow http te:chunked len/4`.

A Neutralização Imprópria de Sequências CRLF (Injeção de CRLF) ocorre quando a função `cow cookie:cookie/1` constrói um cabeçalho de requisição Cookie do lado do cliente a partir de pares de nome-valor sem validar os campos. Um invasor que controle esses nomes ou valores pode injetar caracteres como ;, ,, CR, LF ou TAB no cabeçalho serializado. Isso permite o contrabando de cookies (cookie smuggling), onde cookies fantasmas são introduzidos para serem tratados como autênticos pelo servidor receptor, e a divisão de cabeçalho de requisição HTTP (HTTP request header splitting), que permite a anexação de cabeçalhos arbitrários ou o contrabando de uma segunda requisição contra um proxy upstream compartilhado.