Peter Ullrich

**Nome do Software Vulnerável e Versões Afetadas** pragdave earmark versões 1.4.1 e posteriores **Description** A neutralização inadequada de scripts em atributos em uma página web permite cross-site scripting (XSS) armazenado por meio de valores de atributos HTML não escapados. A função ` make att1/2` em `lib/earmark/transform.ex` insere valores de atributos literalmente entre aspas duplas. Embora os nós de texto sejam processados por uma função de escape que codifica aspas duplas como `"`, os valores dos atributos ignoram esse caminho. Consequentemente, um link markdown que contenha aspas duplas na URL ou no título pode fechar o atributo prematuramente, permitindo que o navegador interprete os bytes subsequentes como novos atributos HTML e execute JavaScript arbitrário. **Recommendations** No momento, não há informações sobre uma versão mais recente que contenha a correção para esta vulnerabilidade.

**Nome do Software Vulnerável e Versões Afetadas** grpc versões 0.3.1 até 0.9.x **Descrição** Atacantes não autenticados podem esgotar a memória do BEAM e travar o servidor ao transmitir um corpo de requisição unária grande ou em fluxo lento (slow-trickle). A função `read full body/3` em 'Elixir.GRPC.Server.Adapters.Cowboy.Handler' acumula cada chunk recebido em um único binário crescente sem limite de tamanho. Além disso, quando o cliente omite o cabeçalho `grpc-timeout`, o tempo limite de leitura por chunk é definido como infinito, permitindo que um cliente de fluxo lento mantenha a conexão indefinidamente enquanto a memória cresce. Uma única conexão é suficiente para esgotar a memória do servidor e travar o nó. **Recomendações** Atualize para a versão 1.0.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** elixir-grpc versões 0.8.0 até 0.9.x **Description** Atacantes autenticados podem acessar ou modificar recursos pertencentes a outros usuários ao contrabandear um valor conflitante para qualquer campo vinculado ao caminho via string de consulta ou corpo da requisição. Isso ocorre na função `map request/5` em `Elixir.GRPC.Server.Transcode` (lib/grpc/server/transcode.ex), onde `Map.merge/2` é utilizado com vinculações de caminho como o primeiro argumento, atribuindo-lhes a menor precedência de mesclagem. Consequentemente, uma requisição como 'GET /users/me/profile?user id=victim' ou uma requisição POST contendo `user id` no corpo resulta em uma estrutura protobuf decodificada onde o campo vinculado ao caminho é sobrescrito pelo valor fornecido pelo atacante. Isso permite a evasão de manipuladores que utilizam esses campos para autorização, verificações de propriedade ou escopo de multi-tenancy. Este problema requer que a transcodificação HTTP-para-gRPC esteja habilitada. **Recommendations** Atualize para a versão 1.0.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** Elixir versões 1.5.0 até 1.20.0 **Description** O Consumo Não Controlado de Recursos no módulo Version da biblioteca padrão permite que um invasor cause a negação de serviço através da exaustão de CPU e memória. O analisador de versão converte componentes numéricos em inteiros sem limitar seu comprimento, forçando uma conversão de base-10 para inteiro de precisão arbitrária superlinear e não cedente através de `String.to integer/1` (também conhecido como `:erlang.binary to integer/1`). Este processo trava um agendador BEAM, e componentes maiores podem disparar um `SystemLimitError` não capturado que derruba o processo solicitante. Uma string de aproximadamente um megabyte é suficiente para disparar este problema, e nenhuma autenticação é necessária. O problema é acessível através da rotina `parse digits/2` em `lib/version.ex` e pontos de entrada públicos, incluindo `Version.parse/1`, `Version.parse!/1`, `Version.match?/3`, `Version.compare/2` e `Version.parse requirement/1`. **Recommendations** Atualizar para a versão 1.20.1.

**Nome do Software Vulnerável e Versões Afetadas** elixir-grpc versões 0.4.0 até 0.9.x **Descrição** O manuseio inadequado de dados altamente compactados nos módulos `GRPC.Compressor.Gzip` e `GRPC.Message` permite a negação de serviço por meio de uma bomba de descompressão gzip. A função `decompress/1` em `Elixir.GRPC.Compressor.Gzip` chama `:zlib.gunzip/1` em bytes controlados por um invasor sem limite de tamanho descompactado, verificação de proporção ou decodificação incremental. Isso ocorre automaticamente quando um frame gRPC recebido contém o cabeçalho `grpc-encoding: gzip`. Como o `:zlib.gunzip/1` aloca todo o resultado descompactado como um único binário, uma carga útil pequena e altamente compressível pode expandir-se para vários gigabytes, esgotando o heap do nó BEAM e causando a interrupção por falta de memória (out-of-memory kill). O limite `max receive message length` é ineficaz, pois é aplicado apenas após a descompressão. Isso pode ser explorado por um peer remoto não autenticado utilizando a função `from data/2` em `Elixir.GRPC.Message`. **Recomendações** Atualize para a versão 1.0.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** cowlib versões 2.9.0 e posteriores **Description** 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. **Recommendations** Para as versões 2.9.0 e posteriores, valide todos os valores passados para os construtores de cabeçalhos de campos estruturados, como `item/1` em `cow http struct hd`, e rejeite quaisquer valores que contenham bytes CR ou LF ou que não provenham de uma fonte confiável. Como mitigação temporária, restrinja o uso de dados controlados por atacantes dentro da função `item/1` de `cow http struct hd`.

**Nome do Software Vulnerável e Versões Afetadas** wojtekmach Req versões 0.5.3 a 0.5.9 **Descrição** A Neutralização Imprópria de Sequências CRLF, também conhecida como CRLF Injection, permite o contrabando de parâmetros multipart via metadados de parte influenciados por um atacante. A função `encode form part/2` em `lib/req/utils.ex` constrói os cabeçalhos de cada parte interpolando os valores de `name`, `filename` e `content type` diretamente nas linhas de content-disposition e content-type, sem escape ou remoção de caracteres de Retorno de Carro (CR) e Alimentação de Linha (LF). Um valor contendo aspas, `r` ou ` ` pode fechar o valor entre aspas e iniciar uma nova linha de cabeçalho. Além disso, a adição de `r --<boundary>` pode encerrar a parte atual e prepender uma parte contrabandeada. Isso é especialmente acessível quando o valor é um `%File.Stream{}`, pois o `filename` assume por padrão o `Path.basename(stream.path)`, e nomes de arquivos POSIX podem conter `r` e ` `. Aplicações que encaminham nomes de arquivos, nomes de campos ou tipos MIME controlados pelo usuário através de `Req.post/2` com `form multipart:` permitem que atacantes injetem cabeçalhos arbitrários ou contrabandeiem campos e partes adicionais nas requisições enviadas para serviços downstream. **Recomendações** Atualizar para a versão 0.6.0. Sanitizar valores de `name`, `filename` e `content type` influenciados por atacantes antes de passá-los para `Req.post/2` com `form multipart:`, rejeitando ou removendo qualquer valor que contenha `r`, ` ` ou aspas. Ao encaminhar uploads, derive o `filename` de uma string normalizada em vez de usar `Path.basename/1` em um caminho controlado pelo usuário.

**Nome do Software Vulnerável e Versões Afetadas** gun versões 2.0.0 até 2.3.x **Descrição** 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. **Recomendações** Atualize para a versão 2.4.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** wojtekmach Req versões 0.1.0 a 0.6.0 **Descrição** O manuseio inadequado de dados altamente compactados permite que servidores HTTP controlados por atacantes esgotem a memória de um cliente por meio de corpos de resposta do tipo bomba de descompressão. O pipeline de resposta padrão inclui as funções `decode body()` e `decompress body()`. A função `decode body()` processa o content-type fornecido pelo servidor e chama `:zip.extract(body, [:memory])` para application/zip, `:erl tar.extract({:binary, body}, [:memory])` para application/x-tar e `:erl tar.extract({:binary, body}, [:memory, :compressed])` para application/gzip ou .tgz. Essas operações retornam o conteúdo completo do arquivo descompactado na memória sem um limite de tamanho total. Além disso, `decompress body()` encadeia decodificadores `:zlib`, `:brotli` e `:ezstd` com base no cabeçalho content-encoding, permitindo que as respostas se expandam através de múltiplas camadas sem limite. Como essas etapas são habilitadas por padrão, uma resposta pequena pode expandir-se para vários gigabytes, travando o processo BEAM. **Recomendações** Atualize para a versão 0.6.1. Como solução temporária, desabilite a decodificação automática do corpo passando `decode body: false` para `Req.new()` ou `Req.get!()` em requisições que buscam URLs influenciadas por atacantes. Para ignorar o pipeline de descompressão de content-encoding, passe `raw: true` para garantir que o corpo da resposta permaneça como bytes brutos para verificação de tamanho antes da descompressão.

**Nome do Software Vulnerável e Versões Afetadas** ninenines gun versões 1.0.0 até 2.3.x **Descrição** 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ó. **Recomendações** Atualize para a versão 2.4.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ninenines gun versões 2.0.0 até 2.3.x **Descrição** 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. **Recomendações** Atualize para a versão 2.4.0 ou posterior. Como mitigação temporária, evite conectar-se a servidores HTTP/2 com server push habilitado ou desative a configuração `cookie store`.

**Nome do Software Vulnerável e Versões Afetadas** mint versões 0.2.0 até 1.8.x **Description** Existe um problema onde servidores HTTP/2 controlados por atacantes podem esgotar a memória de um cliente através de inundação de PUSH PROMISE. No arquivo lib/mint/http2.ex, a função `decode push promise headers and add response/5` insere uma entrada `:reserved remote` em `conn.streams` para cada ID de stream prometido. A função `assert valid promised stream id/2` apenas verifica se o ID prometido é par e se já não está presente, falhando em consultar `client settings.max concurrent streams` no momento da promessa. Como o limite de concorrência é verificado apenas quando os HEADERS de resposta chegam, um servidor que envia quadros PUSH PROMISE, mas retém os HEADERS correspondentes, pode fixar entradas em `conn.streams` sem um limite superior, levando ao esgotamento da memória. Isso é possível porque o push de servidor HTTP/2 é habilitado por padrão via `client settings.enable push`. **Recommendations** Atualize para a versão 1.9.0 ou posterior. Como alternativa temporária, desabilite o push de servidor HTTP/2 em conexões com servidores não confiáveis passando `client settings: [enable push: false]` para a função `connect/4`.

**Nome do Software Vulnerável e Versões Afetadas** tesla versões 1.4.0 até 1.18.2 **Description** O manuseio inadequado de sensibilidade a maiúsculas e minúsculas no middleware `Tesla.Middleware.FollowRedirects` permite o vazamento de credenciais para origens de terceiros durante redirecionamentos cross-origin. O sistema utiliza uma comparação de string sensível a maiúsculas/minúsculas contra uma lista de filtros em letras minúsculas contendo `authorization` e `host` para remover cabeçalhos sensíveis. No entanto, como os nomes dos cabeçalhos HTTP não diferenciam maiúsculas de minúsculas conforme a RFC 7230 e o Tesla preserva as chaves dos cabeçalhos exatamente como fornecidas, cabeçalhos que utilizam a capitalização canônica, como `Authorization`, não correspondem ao filtro em letras minúsculas e são encaminhados para o destino do redirecionamento. Um invasor capaz de influenciar uma resposta `Location:` pode capturar tokens de portador ou outros materiais de autorização. **Recommendations** Atualize para a versão 1.18.3. Normalize todas as chaves de cabeçalho para letras minúsculas antes de passá-las para o software, especificamente utilizando `authorization` em vez de `Authorization` ao definir cabeçalhos via `Tesla.put header/3` ou `Tesla.Middleware.Headers`.

**Nome do Software Vulnerável e Versões Afetadas** mint versões 0.1.0 até 1.8.x **Description** A Neutralização Imprópria de Sequências CRLF, também conhecida como CRLF Injection, permite a Divisão de Requisições HTTP (HTTP Request Splitting) e o Contrabando de Requisições HTTP (HTTP Request Smuggling). Na função `encode request line/2` dentro de `lib/mint/http1/request.ex`, os argumentos `method` e `target` são inseridos diretamente na linha de requisição HTTP/1 sem validação de caracteres. Aplicações que encaminham entradas controladas por atacantes como o método HTTP ou alvo para a função `Mint.HTTP.request/5` estão expostas à injeção de CRLF na linha de requisição. Isso permite que um atacante encerre a linha de requisição prematuramente, injete cabeçalhos arbitrários e realize o contrabando de uma requisição HTTP pipelined separada na mesma conexão TCP. Embora a função `validate request target/2` introduzida na versão 1.7.0 rejeite caracteres CRLF e de controle no `target` por padrão, o campo `method` permanece sem validação em todas as versões. **Recommendations** Atualize para a versão 1.9.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** tesla versões 0.8.0 até 1.18.2 **Description** A Neutralização Imprópria de Sequências CRLF em Cabeçalhos HTTP, também conhecida como HTTP Request/Response Splitting, permite a injeção de cabeçalhos HTTP. A função `add content type param/2` no módulo `Tesla.Multipart` anexa strings fornecidas pelo chamador à lista `content type params` sem validar caracteres de Retorno de Carro (`r`) ou Alimentação de Linha (` `). Posteriormente, a função `headers/1` em `Tesla.Multipart` junta esses parâmetros literalmente para construir o valor do cabeçalho Content-Type de saída. Se um parâmetro contiver `r `, ele divide a linha do cabeçalho, permitindo a injeção de cabeçalhos arbitrários na requisição HTTP de saída. Isso ocorre quando uma aplicação encaminha entradas não confiáveis, como um charset ou string de parâmetro fornecido pelo usuário, para a função `add content type param/2`. **Recommendations** Atualize para a versão 1.18.3 ou posterior. Como medida paliativa temporária, valide as strings de parâmetros de content-type antes de passá-las para a função `add content type param/2`, rejeitando qualquer valor que contenha `r` ou ` `.

**Nome do Software Vulnerável e Versões Afetadas** mint versões 0.1.0 até 1.8.x **Description** Uma interpretação inconsistente de requisições HTTP, conhecida como HTTP Request/Response Smuggling, permite que servidores HTTP/1 controlados por atacantes dessincronizem o enquadramento de respostas em conexões compartilhadas. O problema ocorre porque o analisador de Content-Length do HTTP/1, especificamente a função `content length header/1` em `lib/mint/http1/parse.ex`, utiliza `Integer.parse/1` para processar valores de cabeçalho. Isso permite prefixos opcionais de sinal de mais (+) ou menos (-); embora valores negativos sejam rejeitados, entradas como `+0` ou `+123` são aceitas como comprimentos válidos, contrariando a RFC 7230, que permite apenas dígitos. Um proxy frontal ou balanceador de carga que aplique a gramática rigorosamente pode rejeitar ou reenquadrar tais cabeçalhos, enquanto o Mint os trata como válidos. Quando os sockets são reutilizados via keep-alive, pipelining ou conexões agrupadas compartilhadas entre requisitantes, essa divergência permite que bytes de uma resposta sejam atribuídos à seguinte, potencialmente vazando dados para o fluxo de resposta de outro consumidor se a conexão for compartilhada entre limites de confiança. **Recommendations** Atualize para a versão 1.9.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** elixir-mint versões 0.1.0 até 1.8.x **Description** Existe um problema onde servidores HTTP/2 controlados por atacantes podem causar exaustão de memória em um cliente. Isso ocorre porque o caminho de recebimento HTTP/2 não limita o acumulador quando um quadro HEADERS é observado sem a flag END HEADERS. Quadros CONTINUATION subsequentes são anexados a `conn.headers being processed` sem limites de tamanho por fluxo ou limites de contagem de quadros. Além disso, `max header list size` é aplicado apenas a solicitações de saída e não a blocos de cabeçalho de entrada. Um servidor malicioso pode transmitir uma sequência infinita de quadros CONTINUATION, elevando o iolist do cliente a um tamanho arbitrário, o que leva à exaustão de memória e à interrupção do processo BEAM. **Recommendations** Atualize para a versão 1.9.0 ou posterior. Restrinja as conexões com servidores não confiáveis ao HTTP/1, passando `protocols: [:http1]` para a função `Mint.HTTP.connect/4` para evitar completamente o caminho de recebimento HTTP/2 vulnerável.

**Nome do Software Vulnerável e Versões Afetadas** tesla versões 0.8.0 até 1.18.2 **Descrição** A codificação ou escape inadequado de saída permite a injeção de cabeçalho de parte multipart por meio de valores de parâmetro `Content-Disposition` não escapados. A função `part headers for disposition()` interpola parâmetros de disposição sem validar caracteres de retorno de carro (`r`), alimentação de linha (` `) ou aspas duplas. Esses valores são recebidos do chamador via `add field()` (parâmetro `name`), `add file()` (parâmetro `filename`) e `add file content()` (parâmetro `filename` e outras opções de disposição). Um caractere de aspas duplas pode fechar prematuramente um parâmetro citado, enquanto sequências `r ` podem encerrar o cabeçalho `Content-Disposition` para iniciar um novo cabeçalho forjado ou encerrar o bloco de cabeçalhos para prepender bytes ao corpo da parte. Além disso, o caminho do nome de arquivo padrão em `add file()` utiliza `Path.basename()`, que não remove retornos de carro ou alimentações de linha. **Recomendações** Atualize para a versão 1.18.3. Valide os valores dos parâmetros de disposição antes de passá-los para `add field()`, `add file()` ou `add file content()`, rejeitando qualquer valor que contenha `r`, ` ` ou aspas duplas.

**Nome do Software Vulnerável e Versões Afetadas** tesla versões 0.6.0 até 1.18.2 **Descrição** O manuseio inadequado de dados altamente compactados permite a negação de serviço por meio de uma bomba de descompressão em corpos de resposta HTTP. Quando `Tesla.Middleware.DecompressResponse` ou `Tesla.Middleware.Compression` é incluído em um pipeline de middleware, os corpos de resposta são descompactados ansiosamente sem limite de tamanho. Especificamente, a função `decompress body/2` passa todo o corpo da resposta para `:zlib.gunzip/1` ou `:zlib.unzip/1` sem limitar o tamanho da saída. Além disso, a função `compression algorithms/1` divide o cabeçalho `content-encoding` por vírgulas, e a `decompress body/2` recursa para cada token. Um servidor que forneça múltiplas camadas de gzip no cabeçalho `content-encoding` pode causar amplificação exponencial, onde um payload pequeno infla para gigabytes de heap BEAM, esgotando a memória e travando ou congelando o processo. **Recomendações** Atualize para a versão 1.18.3. Como medida paliativa temporária, evite incluir `Tesla.Middleware.DecompressResponse` ou `Tesla.Middleware.Compression` no pipeline de middleware do Tesla.

**Nome do Software Vulnerável e Versões Afetadas** tesla versões 1.3.0 até 1.18.2 **Descrição** Um problema no Tesla.Adapter.Mint permite a negação de serviço via exaustão da tabela de átomos. A função `open conn/2` converte o esquema de URL de requisições de saída em um átomo BEAM usando `String.to atom(uri.scheme)` sem validação de lista de permissões. Átomos BEAM são entradas permanentes que não são coletadas pelo garbage collector e são limitadas a uma tabela de aproximadamente 1.048.576 entradas. Um invasor capaz de influenciar a URL da requisição — por meio de recursos de encaminhamento de URL no nível da aplicação, como webhooks, proxies ou importadores, ou via um cabeçalho Location quando o `Tesla.Middleware.FollowRedirects` está ativo — pode criar um novo átomo para cada requisição variando a string do esquema. Quando a tabela de átomos fica cheia, a máquina virtual falha, resultando no desligamento completo da aplicação. **Recomendações** Atualizar para a versão 1.18.3.