Eric Meadows-Jönsson

**Nome do Software Vulnerável e Versões Afetadas** Erlang/OTP versões 17.0 até 27.3.4.16 Erlang/OTP versões 28.0 até 28.5.0.5 Erlang/OTP versões 29.0 até 29.0.5 snmp versões 4.25.1 até 5.18.2.0 snmp versões 5.19 até 5.20.2.1 snmp versões 5.20.3 até 5.20.4 **Description** A validação inadequada da quantidade especificada na entrada no módulo snmp permite que um invasor remoto degrade a disponibilidade. Um invasor pode enviar uma mensagem SNMP contendo um BER INTEGER cujo campo de comprimento seja arbitrariamente grande. A função `snmp pdus:dec integer notag/1` define seu limite de tamanho como infinito por padrão, e a função `do dec integer notag/2` acumula o valor em cada byte declarado com um deslocamento recursivo e um operador or bit a bit. O volume de trabalho cresce superlinearmente em relação ao comprimento declarado, pois cada operação atua sobre um bignum progressivamente maior. Embora exista uma variante com limite de tamanho `dec integer notag/2`, ela é acessada apenas por `dec snmp version/1`. Outros campos, como o identificador de requisição, status de erro, índice, campos de armadilha genéricos e específicos, boots e tempo do engine, e todos os valores de varbind decodificados por `dec value/1`, utilizam a forma ilimitada. A decodificação ocorre antes do processamento do PDU, portanto, nenhuma requisição válida é necessária para acionar o problema. **Recommendations** Atualize o Erlang/OTP para a versão 27.3.4.17 ou posterior. Atualize o Erlang/OTP para a versão 28.5.0.6 ou posterior. Atualize o Erlang/OTP para a versão 29.0.6 ou posterior. Atualize o snmp para a versão 5.18.2.1 ou posterior. Atualize o snmp para a versão 5.20.2.2 ou posterior. Atualize o snmp para a versão 5.20.5 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** Erlang/OTP versões 17.0 até 27.3.4.16 Erlang/OTP versões 28.0 até 28.5.0.5 Erlang/OTP versões 29.0 até 29.0.5 **Description** A validação inadequada de quantidades de entrada no módulo inets httpc permite que um servidor HTTP malicioso ou comprometido degrade a disponibilidade. O problema ocorre quando o servidor retorna um cabeçalho numérico contendo uma sequência excessivamente longa de dígitos. Especificamente, o arquivo `httpc handler.erl` utiliza a função `list to integer/1` para converter o cabeçalho `Content-Length` antes de compará-lo com `max body size`, o que significa que a verificação de tamanho não impede o processo de conversão. Conversões ilimitadas semelhantes existem na função `format response/1` para `Content-Length` e na função `get ms from retry after/1` para o cabeçalho `Retry-After`. Como a função de conversão suporta aritmética de precisão arbitrária, o processamento de até 1,26 milhão de dígitos pode consumir recursos significativos de CPU, causando atrasos de centenas de milissegundos por resposta para o processo solicitante. **Recommendations** Atualize o Erlang/OTP para a versão 27.3.4.17 ou posterior. Atualize o Erlang/OTP para a versão 28.5.0.6 ou posterior. Atualize o Erlang/OTP para a versão 29.0.6 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** Erlang/OTP versões 17.0 até 27.3.4.16 Erlang/OTP versões 28.0 até 28.5.0.5 Erlang/OTP versões 29.0 até 29.0.5 **Description** A validação inadequada da quantidade de entrada no módulo eldap permite que um servidor LDAP malicioso ou comprometido degrade a disponibilidade. O problema ocorre quando o servidor retorna uma URL de referência cujo componente de porta consiste em uma sequência excessivamente longa de dígitos. A função `parse port/2` passa a substring da porta para `list to integer/1` sem um limite de comprimento. Como a função de conversão aceita inteiros de qualquer tamanho, uma porta sintaticamente válida de até aproximadamente 1,26 milhão de dígitos pode ser processada, consumindo recursos significativos de CPU por meio de aritmética de precisão arbitrária. Esta falha é acionada quando uma aplicação passa uma referência fornecida pelo servidor para a função `parse ldap url/1`. **Recommendations** Atualize o Erlang/OTP para a versão 27.3.4.17 ou posterior. Atualize o Erlang/OTP para a versão 28.5.0.6 ou posterior. Atualize o Erlang/OTP para a versão 29.0.6 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** Erlang/OTP versões 21.0 até 27.3.4.16 Erlang/OTP versões 28.0 até 28.5.0.5 Erlang/OTP versões 29.0 até 29.0.5 stdlib versões 3.5 até 6.2.2.4 stdlib versões 7.0 até 7.3.0.1 stdlib versões 8.0 até 8.0.3 **Description** A validação inadequada da quantidade especificada na entrada no stdlib permite que um invasor remoto degrade a disponibilidade ao fornecer uma URI cujo componente de porta seja uma sequência muito longa de dígitos. A função `uri string:get port/1` passa a substring da porta para `binary to integer/1` sem limite de comprimento. Consequentemente, uma porta sintaticamente válida de até aproximadamente 1,26 milhão de dígitos pode ser convertida com sucesso, consumindo centenas de milissegundos de aritmética de precisão arbitrária no processo solicitante. Essa conversão é alcançada por todos os caminhos de análise de autoridade em `uri string:parse/1`, incluindo as formas de host, nome registrado, IPv4 e IPv6. Qualquer aplicação que utilize `uri string:parse/1` para analisar URIs fornecidas por invasores está exposta. **Recommendations** Atualize o Erlang/OTP para a versão 27.3.4.17 ou posterior. Atualize o Erlang/OTP para a versão 28.5.0.6 ou posterior. Atualize o Erlang/OTP para a versão 29.0.6 ou posterior. Atualize o stdlib para a versão 6.2.2.5 ou posterior. Atualize o stdlib para a versão 7.3.0.2 ou posterior. Atualize o stdlib para a versão 8.0.4 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** hexpm versões 2025-10-18 through 2026-08-23 **Description** Um problema de autorização incorreta existe no endpoint de token OAuth. Uma chave de API com a permissão `repositories` pode ser usada para ler pacotes privados pertencentes a outra organização. Isso ocorre durante o processo de concessão `client credentials` do OAuth na função `validate scopes against key/2` em `lib/hexpm web/controllers/api/oauth controller.ex`, que permite um escopo solicitado sempre que a chave possui a permissão `repositories` e a string de escopo começa com `repository:`. Como o nome da organização não é resolvido em relação ao principal e a função `expand repositories scope/3` apenas reescreve o escopo literal `repositories`, um escopo explícito `repository:<name>` é aceito. Consequentemente, as bordas do CDN autorizam o acesso com base na reivindicação do token sem verificação no banco de dados, concedendo acesso de leitura aos pacotes privados da organização especificada até que o token expire. **Recommendations** Atualize o hexpm para uma versão lançada em ou após 24-08-2026.

**Nome do Software Vulnerável e Versões Afetadas** hex.pm versões 2025-10-10 a 2026-08-23 **Description** Um problema de expiração de sessão insuficiente existe na concessão de atualização de token OAuth. A função `expand repositories scope/3` em `lib/hexpm/permissions.ex` reescreve apenas o escopo literal de repositórios, permitindo que escopos concedidos explicitamente como `repository:<org>` ou `docs:<org>` permaneçam inalterados. Durante o processo de atualização da concessão, um novo token é derivado dos `granted scopes` armazenados sem verificar novamente a associação à organização. Como as bordas do CDN autorizam o acesso com base na reivindicação do token sem consultar o banco de dados, usuários removidos de uma organização podem manter o acesso de leitura a pacotes privados por até 30 dias, que é a vida útil do token de atualização, em vez da vida útil pretendida de 30 minutos do token de acesso. **Recommendations** Atualize o hex.pm para uma versão lançada em ou após 24-08-2026.

**Nome do Software Vulnerável e Versões Afetadas** elixir-mint versões 0.1.0 até 1.9.2 **Description** Um problema de HTTP response smuggling ocorre devido à interpretação inconsistente de requisições HTTP. Um servidor HTTP/1 malicioso pode dessincronizar um intermediário rigoroso e o cliente Mint em uma conexão agrupada (pooled), permitindo o envenenamento da fila de respostas para requisições subsequentes que compartilham a mesma conexão. A função `decode body()` em `lib/mint/http1.ex` utiliza `Integer.parse(data, 16)` para analisar a linha de tamanho do chunk em uma resposta Transfer-Encoding: chunked. Embora a RFC 7230 proíba prefixos de sinal para o tamanho do chunk, a função `Integer.parse/2` aceita sinais de + ou - iniciais. Consequentemente, uma linha de tamanho de chunk +5 é aceita como um chunk de cinco bytes, e +0 ou -0 são aceitos como chunks de comprimento zero terminadores, encerrando o corpo da mensagem prematuramente. Um intermediário rigoroso à RFC rejeita essas formas, fazendo com que o intermediário e o cliente Mint discordem de onde termina uma resposta e começa a próxima. Em conexões keep-alive agrupadas, uma origem influenciada por um invasor pode injetar bytes que o cliente atribui à próxima resposta legítima na mesma conexão, corrompendo as respostas retornadas a requisições não relacionadas em andamento. Isso requer uma topologia de implantação na qual um intermediário HTTP/1 rigoroso (como um proxy, balanceador de carga ou WAF) esteja posicionado entre o cliente Mint e a origem, e as conexões sejam reutilizadas. **Recommendations** Atualize o elixir-mint para a versão 1.9.3 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** elixir-mint versões 0.1.0 até 1.9.1 **Description** Um servidor HTTP remoto pode causar a negação de serviço ao esgotar a memória no host cliente. As funções `Mint.HTTP1.decode headers/5` e `Mint.HTTP1.decode trailer headers/4` acumulam cabeçalhos de resposta analisados e campos de trailer fragmentados em uma lista por requisição `request.headers buffer` que persiste entre segmentos TCP. Como não há limite para o número de cabeçalhos ou bytes totais, e o analisador `:erlang.decode packet(:httph bin, binary, [])` é utilizado com limites de tamanho padrão ilimitados, um servidor malicioso pode transmitir linhas de cabeçalho ou trailer indefinidamente sem enviar a linha em branco de terminação. Isso faz com que o estado da conexão cresça sem limites até que o nó BEAM seja encerrado pelo manipulador de falta de memória do sistema operacional. **Recommendations** Atualize o elixir-mint para a versão 1.9.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** elixir-mint versões 0.1.0 até 1.9.1 **Description** Um servidor HTTP/2 remoto pode causar exaustão de memória e a negação de serviço no host cliente. A função `handle continuation/3` em `lib/mint/http2.ex` acumula fragmentos de blocos de cabeçalho de quadros CONTINUATION do HTTP/2 em uma estrutura de aninhamento que só é liberada ao receber um quadro com a flag END HEADERS. Embora exista uma verificação de limite de tamanho via `assert header block within max size/2`, o protocolo permite que quadros CONTINUATION tenham cargas úteis de comprimento zero. Um invasor pode enviar uma cadeia ilimitada desses quadros de comprimento zero, o que ignora o limite de tamanho e aumenta continuamente o consumo de memória ao adicionar uma célula cons por quadro, levando eventualmente à terminação por falta de memória do nó BEAM. **Recommendations** Atualize o elixir-mint para a versão 1.9.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** hpax versões 0.1.1 até 1.0.3 **Descrição** Um problema de complexidade algorítmica ineficiente ocorre durante a decodificação de inteiros HPACK de comprimento variável. A função `Elixir.HPAX.Types`:decode remaining integer/3, acessada através do ponto de entrada `Elixir.HPAX`:decode/2, não impõe um limite superior ao valor decodificado ou ao número de octetos de continuação. Como os inteiros BEAM utilizam precisão arbitrária, uma sequência de octetos de continuação cria um bignum de O(N) bits, resultando em um custo de decodificação superlinear de aproximadamente O(N^2). Um invasor não autenticado pode explorar isso enviando um pequeno bloco de cabeçalho HTTP/2 que consome CPU e memória transitória excessivas, levando a uma amplificação de negação de serviço. **Recomendações** Atualize o hpax para a versão 1.0.4 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** mint versões 0.5.0 até 1.9.0 **Description** Um problema de negação de serviço existe no módulo `Mint.HTTP1`. Ao decodificar um corpo de resposta HTTP fragmentado (chunked), o software acumula fragmentos parciais no `data buffer` (um iolist ilimitado) usando a função `add body to buffer/2` e não emite os dados até que o comprimento total do fragmento declarado seja recebido. Como o tamanho do fragmento é analisado a partir do servidor sem um limite superior, um servidor malicioso pode especificar um tamanho de fragmento enorme e enviar bytes lentamente. Isso força o cliente a armazenar dados indefinidamente, podendo levar a uma condição de falta de memória (out-of-memory). Isso pode ser desencadeado quando um cliente segue redirecionamentos, busca URLs fornecidas pelo usuário ou processa webhooks. O problema está associado à função `decode body/5` no arquivo `lib/mint/http1.ex`. **Recommendations** Atualize o mint para a versão 1.9.1 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** 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** 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** 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** 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** ericmj decimal versões 0.1.0 até 2.x **Descrição** O Consumo Não Controlado de Recursos permite a Negação de Serviço remota não autenticada. A biblioteca não limita o expoente na entrada analisada, o que significa que um decimal com um expoente excessivamente grande pode ser armazenado sem erro. Chamadas subsequentes para funções como `Decimal.add/2`, `Decimal.sub/2`, `Decimal.div/2`, `Decimal.to integer/1`, `Decimal.round/3`, `Decimal.compare/3` com um limite, ou `Decimal.to string/2` usando os formatos :normal ou :xsd, alocam memória proporcional ao valor do expoente. Isso pode esgotar a memória disponível e travar a BEAM VM (a Máquina Virtual Erlang). Qualquer aplicação que aceite entrada decimal fornecida pelo usuário para aritmética, arredondamento, conversão de inteiros ou formatação de string está exposta, pois uma única requisição maliciosa pode causar a queda do sistema por falta de memória. **Recomendações** Atualize para a versão 3.0.0 ou posterior.