Peter Ullrich

## Summary Improper Neutralization of Escape, Meta, or Control Sequences vulnerability in ash-project usage rules allows a malicious package publisher to inject terminal control sequences into the output of `mix usage rules.search docs`. `mix usage rules.search docs` searches Hex documentation through `search.hexdocs.pm`, which indexes the documentation of every published package, and prints the matching results (title, package, type, doc reference, and highlighted snippets) to the terminal. The formatter in `Mix.Tasks.UsageRules.SearchDocs` interpolated those publisher-controlled fields verbatim, neutralizing no terminal control characters; the only transform it applied adds escape sequences rather than removing them. A malicious package can embed ANSI terminal escape sequences (cursor movement, line erase, carriage returns, OSC 52 clipboard writes) in its indexed documentation, so when a developer runs a search that surfaces those docs the sequences reach the terminal unchanged — forging the displayed hexdocs URL or a suggested command, hiding text, or writing to the clipboard. No authentication or privileged position is required; only publishing a package. This issue affects usage rules: from 0.1.18 before 1.2.8. ## Configurations Reachable only when a developer runs `mix usage rules.search docs` in a terminal emulator that interprets ANSI escape sequences and the results include documentation from an attacker-published package (for example a broad `--everywhere` search).

## Summary Improper Protection of Alternate Path vulnerability in ash-project ash authentication oauth2 server exposes the state-changing OAuth endpoints under an unintended URL prefix, bypassing controls scoped to the canonical prefix. `oauth2 server protocol routes/1` in `AshAuthentication.Phoenix.Oauth2Server.Router` forwards the same `ProtocolRouter` at both the `/oauth` prefix and the `/.well-known` prefix. Phoenix `forward` strips the matched prefix before dispatch, so the full route table answers under both mounts, and `POST /register`, `POST /token`, and `POST /revoke` are reachable as `/.well-known/register`, `/.well-known/token`, and `/.well-known/revoke`. Edge controls such as WAF rules, rate limits, or authentication exemptions written against the `/oauth` paths, or that allow-list `/.well-known` as unauthenticated, do not apply to the alias. This issue affects ash authentication oauth2 server: from 0.1.0 before 0.3.1. ## Configurations The routing alias is unconditional. Exploitable impact depends on the deployment applying path-scoped edge controls (WAF, rate limiting, auth-redirect exemptions) to the `/oauth` prefix, or allow-listing `/.well-known` as unauthenticated, that the alias then bypasses.

## Summary Improper Protection of Alternate Path vulnerability in ash-project ash lua allows a user-supplied Lua script to read attributes that are not on the exposed-field allow-list. AshLua exposes Ash resources to Lua scripts, gated by a manifest declaring which fields are exposed. The `read` action's `operation` aggregate path in `AshLua.Runtime` took the field name straight from the Lua call and resolved it with only `String.to existing atom` and `Ash.Query.Aggregate.new!`, neither of which consults the exposed-field allow-list the normal `fields` path enforces. A script can therefore read the value of any attribute of any record the actor may read, including private `sensitive?: true` columns, via `resource.read({ operation = {"list", "hashed password"} })`; `min` and `max` give a value oracle. Anyone able to submit or influence a Lua script can reach this. This issue affects ash lua: from 0.1.0 before 0.2.1. ## Configurations Reachable only when an application exposes AshLua scripting (the `AshLua.Resource` / `AshLua.Domain` extensions) to callers who can submit or influence Lua scripts, and the exposed resource has attributes that are not on the exposed-field surface.

## Summary Improper Authentication vulnerability in ash-project ash authentication oauth2 server allows an unauthenticated attacker to register OAuth clients even when Dynamic Client Registration is gated by an initial access token. `resolve secret/3` in `AshAuthentication.Oauth2Server` (reached through ` resolve secret !`) treated any return other than `{:ok, }` or `:error` from a configured `{module, function, args}` or 2-arity-function secret provider as a valid secret, wrapping `nil`, `false`, or `""` as `{:ok, value}`. When the `initial access token` resolves to such an empty value, `POST /oauth/register` compares the presented bearer token against it and the comparison passes with no token supplied, so registration is open although it was configured closed. The same fail-open affected other resolved secrets such as `signing secret`. This issue affects ash authentication oauth2 server: from 0.1.0 before 0.3.1. ## Configurations Reachable only when the server configures an `initial access token` (so Dynamic Client Registration is meant to require one) and the configured secret provider returns an empty value (`nil`, `false`, or `""`) or an `{:error, }` for it, rather than a non-empty binary.

## Summary Allocation of Resources Without Limits or Throttling vulnerability in ash-project ash authentication oauth2 server allows an unauthenticated attacker to exhaust database storage and memory. The `/authorize` endpoint is unauthenticated by design. With Client ID Metadata Documents enabled, `resolve client/3` in `AshAuthentication.Oauth2Server.CIMD` fetches the document for each new URL-shaped `client id` and upserts a client row, with no cap on the number of rows, no expiry or garbage collection, and no length bound on the fetched fields; the document was also placed in `CIMD.Cache` before validation, so even rejected documents held cache memory until their TTL. An attacker serving valid documents at many distinct URLs creates one permanent client row per URL, each able to carry multi-megabyte strings, growing storage and memory without bound. This issue affects ash authentication oauth2 server: from 0.3.0 before 0.3.1. ## Configurations Reachable only when the client resource has Client ID Metadata Documents enabled (`cimd enabled?: true`) and the authorize endpoint is exposed. CIMD is off by default.

## Summary Improper Handling of Alternate Encoding vulnerability in ash-project ash double entry allows an attacker to submit several distinct string spellings of the same identifier. `AshDoubleEntry.ULID` renders a 128-bit ULID as 26 Crockford base-32 characters, but the first character encodes only 3 bits, so canonical values are `0` to `7`. `decode/1` in `lib/ulid.ex` masks the first character to its low 3 bits and `valid?/1` accepts all 32 characters in that position, so `0...`, `8...`, `G...` and `R...` decode to the identical 16-byte value and resolve to the same row. When the type is exposed as a public ID over an HTTP or API boundary, an attacker-supplied ID can be spelled differently from the record it actually reads or writes, desynchronizing or bypassing string-level checks such as idempotency and deduplication keys, deny-lists, audit correlation, or signatures computed over the submitted ID. This issue affects ash double entry: from 0.1.0 before 1.0.19. ## Configurations Reachable only when an application exposes `AshDoubleEntry.ULID` as a public identifier over an HTTP or API boundary and performs string-level checks on the submitted ID (idempotency or deduplication keys, deny-lists, audit correlation, or signatures) rather than treating the value as opaque.

## Summary Server-Side Request Forgery (SSRF) vulnerability in ash-project ash authentication oauth2 server allows an attacker who controls a client metadata URL and its DNS to make the server connect to internal or loopback addresses. `public ip?/1` in `AshAuthentication.Oauth2Server.CIMD.ReqFetcher` enforces the outbound policy for CIMD metadata fetches. It classified several address forms as publicly routable that are not: IPv4-compatible `::/96` (for example `::127.0.0.1`), SIIT IPv4-translated `::ffff:0:0:0/96`, and deprecated site-local `fec0::/10`. A returned AAAA record in one of these ranges passed the policy, so a fetch pinned to that address reached space the policy was meant to block. This issue affects ash authentication oauth2 server: from 0.3.0 before 0.3.1. ## Configurations Reachable only when Client ID Metadata Documents are enabled (`cimd enabled?: true`), so the authorize endpoint fetches attacker-suppliable metadata URLs, and an internal or loopback target resolves to one of the affected IPv6 address forms.

## Summary Improper Encoding or Escaping of Output vulnerability in ash-project ash authentication oauth2 server allows an unauthenticated attacker to inject arbitrary authentication parameters into the `WWW-Authenticate` challenge header. `BearerPlug` and `RequireScopePlug` built the `Bearer resource metadata="..."` challenge by interpolating a `resource metadata` URL derived from the request tenant directly into the quoted value. In a multi-tenant application that sets the Ash tenant from request-controlled data (a subdomain, the `Host`, a path segment, or a header), a tenant containing a `"` closes the quoted value and appends attacker-chosen auth-params, including a second `resource metadata` URL pointing at an attacker-controlled authorization server that spec-following clients follow. Carriage returns and line feeds are rejected by Plug, so this is parameter injection within one header, not response splitting. This issue affects ash authentication oauth2 server: from 0.1.3 before 0.3.1. ## Configurations Reachable only in a multi-tenant application that derives the Ash tenant from request-controlled input (subdomain, `Host`, path, or header) and uses `BearerPlug` or `RequireScopePlug`; the tenant reaches the challenge through the server's tenant-aware `resource url`.

## Summary Improper Neutralization of Escape, Meta, or Control Sequences vulnerability in ash-project igniter allows a malicious package publisher to forge the `mix igniter.install` confirmation prompt. `mix igniter.install` prints a confirmation panel (an anti-typosquatting safeguard) listing a package's hex metadata before adding it. The panel builder in `Igniter.Project.Deps` wrote publisher-controlled fields (`meta.description`, owner usernames, requirement names, version) to the terminal with only newlines stripped. A malicious or typosquatted package can embed ANSI terminal escape sequences (cursor movement, line erase, carriage returns) in its metadata to overwrite the panel, forging trusted author names and download counts while concealing the real ones, so a developer relying on the panel to vet the package is deceived into approving a malicious dependency. This issue affects igniter: from 0.8.1 before 0.8.4. ## Configurations Reachable only when a developer runs `mix igniter.install` against an untrusted or misspelled package name in a terminal emulator that interprets ANSI escape sequences.

## Summary Use of Cache Containing Sensitive Information vulnerability in ash-project ash authentication oauth2 server allows a shared HTTP cache to serve one tenant's OAuth discovery metadata to another tenant's clients. The RFC 8414 and RFC 9728 metadata endpoints in `AshAuthentication.Phoenix.Oauth2Server.ProtocolRouter` return tenant-specific values (`issuer`, `authorization endpoint`, `token endpoint`, `jwks uri`) when a tenant is set, but sent them with `Cache-Control: public, max-age=3600` and no `Vary`. When the tenant is derived from something other than the URL (a header or the `Host`) and a shared cache sits in front, the cache key is the URL alone, so a stored response for one tenant is served to another for up to an hour. Affected clients may then send authorization codes and secrets to the wrong tenant's token endpoint and validate tokens against the wrong keys. This issue affects ash authentication oauth2 server: from 0.1.3 before 0.3.1. ## Configurations Reachable only in a multi-tenant deployment where the tenant is derived from outside the request URL (a header or the `Host`) and a shared HTTP cache (CDN, reverse proxy) sits in front of the metadata endpoints.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 3.0.0-rc.17 até 3.32.1 **Description** O software não lida com exceções de forma segura durante a execução de uma etapa de alteração do Ash.Reactor. Quando um guardião que controla uma alteração é avaliado na função `apply where clauses/3` dentro de `Ash.Reactor.ChangeStep`, qualquer exceção levantada é resgatada e tratada como uma condição que não foi atendida. Isso faz com que o sistema ignore a alteração completamente em vez de interromper o processo. Consequentemente, se um invasor fornecer entradas específicas que desencadeiem uma exceção no guardião, modificações relevantes para a segurança que deveriam ser aplicadas por essa alteração são ignoradas, resultando em um cenário de falha aberta (failing open). **Recommendations** Atualize o ash para a versão 3.32.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 2.14.18 até 3.32.1 **Description** Uma validação inadequada de entrada no ash-project ash permite que um invasor cause confusão de tipo ao manipular a tag de tipo armazenada de um valor `Ash.Type.Union` que utiliza `storage: :map with tag`. Isso ocorre porque a função `dump to native/2` em `lib/ash/type/union.ex` não força a tag configurada ao gravar valores, permitindo que uma tag fornecida no valor enviado seja persistida literalmente. Consequentemente, um invasor pode armazenar dados pertencentes a um membro enquanto atribui a ele a tag de um membro diferente. Na leitura, o sistema trata o valor como o membro incompatível, ignorando restrições de validação e políticas de autorização baseadas em tags. **Recommendations** Atualize o ash para a versão 3.32.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash typescript versões 0.1.0 até 0.17.9 **Description** Um invasor não autenticado pode causar a negação de serviço ao esgotar a tabela de átomos do BEAM, levando ao aborto do nó. Isso ocorre porque a função `convert to field atom/2` em `lib/ash typescript/field formatter.ex` utiliza `String.to atom/1` para converter nomes de campos fornecidos pelo cliente em átomos quando nenhum átomo correspondente existe. O processo envolve a função `parse input field/2`, que tenta resolver o nome usando `String.to existing atom/1`, mas retorna uma string simples, que é então transformada em um átomo permanente. Como os átomos não são coletados pelo garbage collector, o fornecimento de inúmeros nomes de campos distintos via seleção de campos RPC através do `AshTypescript.Rpc.FieldProcessing.FieldSelector` eventualmente preencherá a tabela de átomos. Além disso, fornecer um nome de campo com mais de 255 caracteres dispara um `SystemLimitError` não tratado. O problema é acessível quando a aplicação expõe um endpoint RPC do AshTypescript via HTTP, permitindo que a entrada chegue ao `AshTypescript.Rpc.run action/3`. **Recommendations** Atualize o ash typescript para a versão 0.18.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 2.19.0 through 3.32.1 **Description** Um problema de consumo descontrolado de recursos existe onde uma leitura assíncrona lenta pode fazer com que uma thread do agendador opere em capacidade total de CPU. Isso ocorre porque a função `await at least one()` em `Ash.Actions.Read.AsyncLimiter` monitora tarefas de leitura assíncronas concorrentes usando `Task.yield(task, 0)` em um loop fechado em vez de bloquear. Quando tarefas pendentes, como carregamentos de dados relacionados lentos ou cálculos, ainda estão em execução, o loop se repete imediatamente, resultando em um busy-spinning que consome um agendador BEAM. Leituras lentas concorrentes podem ocupar agendadores adicionais. **Recommendations** Atualizar para a versão 3.32.2.

**Nome do Software Vulnerável e Versões Afetadas** ash typescript versões 0.11.0 até 0.17.9 **Description** Um invasor não autenticado pode causar a negação de serviço ao esgotar a tabela de átomos do BEAM, levando ao aborto do nó. Isso ocorre quando a função `resolve typed struct field/2` em `lib/ash typescript/rpc/field processing/field selector.ex` processa nomes de campos de estruturas tipadas fornecidos pelo cliente. Se um nome de campo não for encontrado no mapa reverso, o sistema utiliza `String.to atom/1` para criar um átomo permanente antes de verificar se o campo existe. Como os átomos não são coletados pelo garbage collector, o envio de inúmeros nomes distintos pode preencher a tabela de átomos até que a máquina virtual atinja seu limite e trave. Este problema ocorre quando um endpoint RPC do AshTypescript está exposto via HTTP e pelo menos um campo de recurso é suportado por um `Ash.TypedStruct`. **Recommendations** Atualize o ash typescript para a versão 0.18.0 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 1.29.0-rc0 até 3.32.1 **Description** Um problema de consumo descontrolado de recursos permite que um invasor esgote a memória do nó ao corresponder a um filtro que abrange múltiplos relacionamentos de muitos-para-muitos em memória. A função `flatten relationships/2` em `lib/ash/filter/runtime.ex` constrói ansiosamente um produto cartesiano completo através dos caminhos de relacionamento de muitos-para-muitos do filtro. Isso faz com que um registro com K relacionamentos de muitos-para-muitos de M linhas cada materialize M^K cenários antes que qualquer predicado seja verificado, resultando em alocação de memória combinatória. **Recommendations** Atualize o ash para a versão 3.32.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 0.4.0 até 3.32.1 **Description** Um problema de controle de acesso inadequado ocorre ao utilizar as camadas de dados ETS ou Mnesia. Essas camadas implementam a ação de criação como uma inserção com chave que não impõe a unicidade da chave primária, diferentemente das camadas de dados SQL. Um invasor capaz de especificar a chave primária durante uma ação de criação pode sobrescrever um registro existente utilizando uma chave correspondente. Isso permite a destruição e substituição silenciosa de dados de outra entidade, ignorando a ação de atualização e suas políticas associadas. **Recommendations** Atualize para a versão 3.32.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 3.6.3 até 3.32.1 **Description** Uma validação de entrada inadequada permite que um invasor negue persistentemente a leitura de um registro ao armazenar um UUID que não seja da versão 7 em um atributo `Ash.Type.UUIDv7`. A função `Ash.Type.UUIDv7.cast input/2` aceita qualquer string UUID bem formada e a armazena como um binário de 16 bytes. Durante o processo de leitura, a função `cast stored/2` encaminha o binário armazenado de volta para `cast input/2`. Como a validação foi restringida, o sistema aceita apenas binários de 16 bytes da versão 7 (e opcionalmente da versão 4) ou strings de 36 caracteres. Um binário de 16 bytes armazenado que não seja v7 não corresponde a nenhum dos casos, resultando em um erro que faz com que todas as leituras subsequentes desse registro falhem, envenenando a linha permanentemente. **Recommendations** Atualize o ash para a versão 3.32.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 1.29.0-rc0 até 3.32.1 **Description** Existe um problema que permite o armazenamento de valores de string insensíveis a maiúsculas e minúsculas que violam restrições de comprimento ou de correspondência. Isso ocorre porque a função `apply constraints/2` em `Ash.Type.CiString` valida as restrições `max length`, `min length` e de correspondência em relação ao valor enviado antes que a string seja normalizada (case-folded) para armazenamento e comparação. Consequentemente, um valor pode passar na validação em sua forma original, mas violar as restrições após ser normalizado e armazenado. **Recommendations** Atualize o ash para a versão 3.32.2.

**Nome do Software Vulnerável e Versões Afetadas** ash versões 2.14.13 through 3.32.1 **Description** Ocorre um estouro de inteiro (integer overflow) ao enviar um vetor com mais de 65.535 elementos. A função `Ash.Vector.new/1` em `lib/ash/vector.ex` compacta a contagem de elementos em um campo de 16 bits sem validação de intervalo, fazendo com que a dimensão sofra um wrap modulo 65.536. Isso resulta em um cabeçalho codificado que diverge do número de floats armazenados. Posteriormente, a função `from binary/1` lê o tamanho do binário com base nesse cabeçalho incorreto, levando a falhas de análise e travamentos que negam o acesso ao registro afetado. **Recommendations** Atualize para a versão 3.32.2 ou posterior.