Jonatan Männchen

**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** 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 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** 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** 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.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** 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 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.

**Nome do Software Vulnerável e Versões Afetadas** oban web versões 2.12.0 até 2.12.4 **Descrição** O Consumo Não Controlado de Recursos no módulo `Elixir.Oban.Web.CronExpr` permite a exaustão de memória através da expansão ilimitada de intervalos de cron. Um invasor com permissões para agendar tarefas cron pode enviar uma expressão cron maliciosa. Quando um usuário com acesso ao painel de controle visualiza a lista de tarefas cron, a função `describe/1` é chamada para renderizar a expressão. A função `parse range/1` analisa os limites do intervalo usando `Integer.parse/1` sem verificação de limites, e os auxiliares `expand dom parts/1` e `expand dow parts/1` materializam o intervalo ansiosamente via `Enum.to list/1`. Esse processo pode levar à alocação de aproximadamente 2,4 GB de memória, resultando no travamento ou falha do nó BEAM (a Máquina Virtual Erlang). **Recomendações** Atualize o oban web para a versão 2.12.5.

**Nome do Software Vulnerável e Versões Afetadas** oban web versões 2.12.0 até 2.12.4 **Descrição** Uma falha de autorização no módulo `Elixir.Oban.Web.Jobs.DetailComponent` permite a substituição não autorizada do trabalhador de um job. O manipulador `handle event("save-job", ...)` não realiza verificações de autorização, ao contrário de outros manipuladores como cancel, delete e retry, que verificam privilégios via `can?/2`. Um usuário autenticado com acesso `:read only` pode enviar um evento de WebSocket LiveView `save-job` forjado para sobrescrever o campo de trabalhador de um job com qualquer outro módulo `Oban.Worker` existente na aplicação. Consequentemente, na próxima tentativa de execução, o Oban invocará a função `perform/1` no módulo escolhido pelo atacante em vez do pretendido. Isso ocorre quando o painel Oban.Web está implantado e acessível a usuários com privilégios limitados de gerenciamento de jobs. **Recomendações** Atualizar para a versão 2.12.5.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 0.9.0 até 4.0.0 **Descrição** A Neutralização Imprópria de Sequências CRLF, também conhecida como CRLF Injection, permite a Divisão de Resposta HTTP (HTTP Response Splitting). A função `setcookie/3` em `src/hackney cookie.erl` valida os argumentos Name e Value contra caracteres de controle e CRLF, mas concatena as opções de domínio e caminho no iolist de saída sem verificações equivalentes. Um invasor que controle essas opções, como ao fornecer um valor de cabeçalho Host como o domínio do cookie ou um caminho de solicitação como o caminho do cookie, pode injetar sequências CRLF literais e cabeçalhos Set-Cookie adicionais arbitrários na resposta HTTP. **Recomendações** Atualize para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 2.0.0-beta.1 até 4.0.0 **Descrição** Um loop infinito existe no analisador do cabeçalho de resposta Alt-Svc em `src/hackney altsvc.erl`. Quando a função `parse token/2` recebe um byte que não seja um token, espaço em branco ou vírgula (como !, @, = ou ;), ela retorna a entrada inalterada. Da mesma forma, a função `skip comma/1` retorna o buffer inalterado se o primeiro byte não for uma vírgula. Isso faz com que a função `parse entries/2` realize a recursão com dados idênticos, criando um loop recursivo de cauda infinito que consome 100% do escalonador de CPU e impede que o processo solicitante retorne. O ponto de entrada `parse and cache/3` é chamado sincronicamente em cada resposta HTTP, o que significa que um cabeçalho de resposta `Alt-Svc: !` de um único byte de qualquer origem HTTP pode causar o travamento. **Recomendações** Atualize o hackney para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 2.0.0 até 4.0.0 **Descrição** Um problema no analisador de URL em `src/hackney url.erl` permite a exaustão de recursos. O analisador utiliza a função `binary to atom/2` para converter esquemas de URL não reconhecidos em átomos BEAM permanentes. Como os átomos BEAM não são coletados pelo garbage collector e a tabela de átomos possui um limite rígido de 1.048.576 entradas, um invasor pode esgotar essa tabela fornecendo URLs com prefixos de esquema personalizados. Isso pode ser feito por meio de alvos de requisição, URLs de webhook configuradas ou cabeçalhos Location durante redirecionamentos, resultando no travamento de toda a VM BEAM com um erro de `system limit`. **Recomendações** Atualizar para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** benoitc hackney versões 3.1.1 até 4.0.0 **Descrição** Um problema de exposição de dados sensíveis existe onde o manipulador de redirecionamento HTTP/3 em `src/hackney h3.erl` passa os cabeçalhos da requisição original para o destino do redirecionamento sem realizar verificações de cross-origin. Se um cliente fizer uma requisição HTTP/3 com `follow redirect` habilitado e incluir cabeçalhos `Authorization` ou `Cookie`, um servidor que responder com um redirecionamento 3xx para um host diferente fará com que o cliente encaminhe essas credenciais integralmente para a nova origem. Isso ocorre porque o `hackney h3.erl` carece da proteção fornecida pela função `maybe strip auth on redirect()` encontrada no módulo principal `hackney.erl`. **Recomendações** Atualizar para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 0.10.0 até 4.0.0 **Descrição** O Consumo Não Controlado de Recursos no transporte SOCKS5 em `src/hackney socks5.erl` permite flooding. Embora o tempo limite fornecido pelo chamador seja aplicado durante a fase de negociação SOCKS5, a atualização da conexão para TLS através da função `ssl:connect/2` assume um tempo limite infinito por padrão, pois a variável `Timeout` não é encaminhada. Consequentemente, um proxy SOCKS5 malicioso que complete o handshake e então fique inativo ou envie um TLS ServerHello parcial pode fazer com que o processo de conexão bloqueie indefinidamente, ignorando as opções `connect timeout` ou `recv timeout`. **Recomendações** Atualize o hackney para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 2.0.0 até 4.0.0 **Description** A Neutralização Imprópria de Sequências CRLF, também conhecida como CRLF Injection, permite a Divisão de Requisição/Resposta HTTP (HTTP Request/Response Splitting). O código de upgrade de WebSocket em `src/hackney ws.erl` copia o host, caminho, cabeçalhos (`ExtraHeaders`) e opções de protocolos do mapa de opções fornecido pelo chamador para o registro interno `#ws data{}` em `init/1` e, em seguida, os insere literalmente na requisição de upgrade HTTP/1.1 bruta por concatenação binária em `do handshake/1`. Como nenhuma remoção de CRLF ou NUL é realizada nesses quatro pontos de injeção, um invasor que controle essas opções — por exemplo, encaminhando componentes de URL ou valores de cabeçalho de entradas não confiáveis para `hackney ws:start link/1` — pode injetar cabeçalhos HTTP arbitrários na requisição de upgrade de WebSocket de saída. Isso pode levar à injeção de cabeçalhos, falsificação de credenciais (credential spoofing) para o servidor upstream, envenenamento de logs e cache, ou contrabando de requisições (request smuggling) via proxies intermediários. **Recommendations** Atualizar para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 2.0.0 a 4.0.0 **Descrição** O cliente WebSocket em `src/hackney ws.erl` não impõe limites superiores ao consumo de memória em três caminhos de código, permitindo inundação (flooding). Primeiro, a função `read handshake response/3` acumula bytes recebidos em um buffer sem limite de tamanho; um servidor que transmite bytes sem a sequência de terminação necessária faz com que o buffer cresça até que a memória seja esgotada. Segundo, as funções `parse payload/9` e `parse active payload/8` não validam o comprimento declarado da carga útil do frame, que pode chegar a 2^63-1 bytes conforme a RFC 6455, levando a condições de Out-of-Memory (OOM) quando um servidor anuncia um frame muito grande. Terceiro, o campo `frag buffer` em `#ws data{}` acumula frames de continuação indefinidamente se um servidor enviar um fluxo de frames fragmentados não finais sem um frame final. Um invasor precisa apenas controlar o servidor WebSocket ao qual o cliente se conecta, sem a necessidade de autenticação ou configuração especial. **Recomendações** Atualizar para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 0 a 4.0.0 **Descrição** A Neutralização Imprópria de Sequências CRLF permite a Divisão de Requisição HTTP (HTTP Request Splitting). O software não realiza a codificação percentual (percent-encode) de caracteres de retorno de carro (`r`) ou alimentação de linha (` `) no componente de consulta da URL antes de construir o alvo da requisição HTTP/1.1. Especificamente, a função `hackney url:make url/3` passa o binário da consulta diretamente sem validação ou escape, violando a seção 3.4 da RFC 3986. Um atacante que controle parte de uma URL pode injetar sequências CRLF brutas na string de consulta, permitindo a injeção de cabeçalhos HTTP arbitrários ou a divisão da requisição HTTP. **Recomendações** Atualizar para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** benoitc hackney versões 0.13.0 até 4.0.0 **Descrição** Um conflito de interpretação permite a ocorrência de Server Side Request Forgery (SSRF), uma falha onde um invasor pode induzir o servidor a fazer requisições para um local não pretendido. A função `hackney url:normalize/2` decodifica a URL do componente de host após a URL ter sido analisada em um registro `#hackney url{}`. Como as funções `uri string:parse/1` e `inet:parse address/1` do OTP não decodificam escapes de porcentagem no host, uma URL contendo caracteres codificados em porcentagem pode burlar validadores de lista de permissões (allowlist) que não reconhecem a string codificada como um endereço IP. Posteriormente, o normalizador decodifica o host (por exemplo, convertendo `%31%32%37%2E%30%2E%30%2E%31` para `127.0.0.1`), permitindo conexões TCP para a interface de loopback, serviços de metadados de instâncias de nuvem (169.254.169.254), redes RFC1918 e interfaces de administração locais. Isso ocorre porque a função `hackney:request/5` sempre invoca `hackney url:normalize/2` sem um mecanismo de exclusão para requisições que utilizam URLs binárias ou em lista. **Recomendações** Atualize o benoitc hackney para a versão 4.0.1.

**Nome do Software Vulnerável e Versões Afetadas** hackney versões 2.0.0 a 4.0.0 **Descrição** Uma alocação de recursos sem limites ou controle de fluxo permite a inundação (flooding). A função `await response loop/6` em `hackney h3` acumula o corpo da resposta HTTP/3 na memória sem um limite de tamanho. Como a cláusula de tempo limite funciona como um temporizador de inatividade por mensagem que é redefinido ao receber chunks, mensagens de manutenção ou quadros de configuração, em vez de um prazo fixo, um servidor HTTP/3 malicioso pode manter o loop ativo indefinidamente. Ao emitir pequenos chunks pouco antes da expiração do tempo limite com `Fin` definido como falso e omitindo um quadro final, o servidor faz com que o buffer de acumulação cresça linearmente, esgotando o heap do processo BEAM e levando a uma condição de falta de memória (out-of-memory). Este problema ocorre quando a aplicação utiliza o transporte HTTP/3 através do `hackney h3` ou ao passar `{transport, h3}` para `hackney:request/5`. **Recomendações** Atualize para a versão 4.0.1. Como mitigação temporária, evite usar o transporte HTTP/3, não chamando o `hackney h3` diretamente e evitando a opção `{transport, h3}` em `hackney:request/5`.