Anthropic

A validação inadequada de arrays RunEndEncoded na interface ArrayData permite a leitura de dados além dos limites do array de valores filho. Isso ocorre durante a validação de arrays RunEndEncoded através da função `ArrayData::validate values`, o que pode levar a uma leitura fora dos limites ao acessar o último valor por meio de APIs como `TypedRunArray::value`.

O Postiz não verifica se os caminhos de mídia que não estão formatados como endereços web estão localizados dentro do diretório de upload designado. Isso permite que um usuário registrado forneça um caminho de mídia manipulado que possibilita ao trabalhador de publicação ler arquivos arbitrários do disco do servidor e enviá-los como anexos para um servidor Discord externo. Além disso, duas outras rotas permitem leituras irrestritas semelhantes: uma que confirma a existência de arquivos e pode levar ao esgotamento da memória do backend, e outra que entrega o arquivo. Como o autorregistro está habilitado por padrão, um invasor pode criar uma conta para explorar esses problemas.

O Postiz utiliza um único segredo compartilhado para assinar tokens de sessão, convite e redefinição de senha sem incluir um marcador para distinguir a finalidade do token. Uma rota utilizada para atualizar as credenciais do canal de extensão do navegador assina dados fornecidos na requisição e armazena o resultado para que o usuário possa recuperá-lo. Isso permite que um usuário forje um token assinado validamente com alegações arbitrárias, que a aplicação pode aceitar como um token de sessão, um convite de organização com uma função específica, um token de redefinição de senha ou um token de provisionamento empresarial. Além disso, uma rota para a criação de convites de equipe assina campos extras do corpo da requisição usando o mesmo mecanismo falho.

O Postiz permite que usuários autenticados solicitem que o backend execute funções em canais conectados sem restringir quais funções podem ser chamadas. Isso permite que usuários acionem funções auxiliares internas que não deveriam estar acessíveis via interface web. Uma dessas funções permite a leitura de arquivos arbitrários no disco do servidor se um canal for conectado utilizando um caminho de arquivo como token, expondo potencialmente variáveis de ambiente, segredos de assinatura de sessão, endereços de banco de dados e credenciais de serviços. Além disso, outra função auxiliar pode ser utilizada para forçar o encerramento do processo do backend, causando a interrupção do serviço. Como o auto-cadastro está habilitado por padrão, essas ações podem ser realizadas por qualquer usuário recém-registrado.

Uma autorização incorreta na porta MPU do Arm Cortex-R82 (Armv8-R AArch64) permite que uma tarefa não privilegiada em compilações com MPU habilitado leia e escreva na memória privilegiada do kernel fora das regiões atribuídas a ela. Isso ocorre por meio de um argumento de buffer passado para uma chamada de sistema MPU.

Ocorre truncamento numérico do comprimento do buffer na verificação de autorização do buffer MPU na porta MPU Arm Cortex-R82 (Armv8-R AArch64). Este problema pode permitir que uma tarefa não privilegiada em compilações com MPU habilitado leia ou grave na memória privilegiada do kernel além da janela de buffer validada, por meio de uma chamada de sistema de buffer de fluxo.

Quando compilado com GnuTLS, um servidor WebSocket malicioso pode fazer com que o curl envie memória além do seu buffer de envio. Isso ocorre devido a uma leitura fora dos limites que acontece quando a função `gnutls record send()` retorna um número de bytes enviados superior ao número de bytes que lhe foi solicitado para enviar, geralmente após um envio bloqueado.

Um estouro de buffer baseado em heap (heap-based buffer overflow write) existe no carregador de dicionários de apenas leitura. A função `String::reserve()` em `common/string.hpp` realiza uma verificação de capacidade usando um inteiro assinado `((int)s + 1)`, o que permite que um tamanho solicitado de `0x7FFFFFFF` envolva para um valor negativo, impedindo o crescimento do buffer de suporte. A função `ReadOnlyDict::load()` em `modules/speller/default/readonly ws.cpp` passa campos de tamanho de 32 bits não validados de um cabeçalho de dicionário `.rws` para este caminho. Consequentemente, um arquivo `.rws` manipulado contendo um marcador endian válido e um campo de comprimento excessivo, como `lang name size` definido como `0x7FFFFFFF`, permite que dados controlados pelo invasor sejam gravados fora dos limites de uma alocação de heap subdimensionada. Isso pode levar à corrupção da memória heap, resultando em negação de serviço ou potencial execução de código se uma vítima for induzida a carregar um dicionário malicioso.

Um heap use-after-free remoto e não autenticado existe no servidor. A função de watchdog por teste `server timer proc()` libera streams sem cancelar ou unir suas threads de trabalho, o que pode levar um trabalhador bloqueado a desreferenciar um `iperf stream` liberado. Um heap use-after-free ocorre quando um programa continua a usar um ponteiro após a memória para a qual ele aponta ter sido liberada.

Um estouro de buffer de heap (heap buffer overflow) de pré-autenticação existe na função `decrypt rsa message()`. Isso ocorre porque um buffer RSA de 256 bytes é lido usando um comprimento de texto cifrado controlado pelo atacante, permitindo que um cliente não autenticado cause o estouro do heap ao fornecer um `authtoken` excessivamente grande.

Uma exposição inadequada de recurso a uma esfera incorreta existe no auxiliar de arquivo do host (gofer) em plataformas Linux com CUSE (Character device for Userspace) habilitado. Um invasor local com privilégios de implantação de imagem de contêiner pode alcançar a execução de código root no sistema host ao incluir um nó de dispositivo de caractere `/dev/cuse` em uma imagem de contêiner. A abertura deste dispositivo permite que o invasor em sandbox registre um dispositivo no host e explore o tratamento irrestrito de ioctl (controle de entrada/saída) para sobrescrever a memória do auxiliar udev root.

Um problema de corrupção de memória do tipo use-after-free ocorre durante uploads HTTP/2. A falha acontece quando o curl manipula incorretamente uma resposta HTTP/2 `RST STREAM` recebida de um servidor com o motivo `HTTP 1 1 REQUIRED` ou `REFUSED STREAM`, levando ao uso após a liberação de um objeto `struct Curl easy`. Um invasor remoto que controle um servidor malicioso pode explorar isso para causar a falha do cliente ou, sob condições altamente específicas envolvendo conhecimento preciso da arquitetura do alvo, layout de memória e configuração TLS, executar código remotamente.

Um estouro de buffer de heap ocorre durante a importação de desenhos no formato DXF usado por softwares CAD. O problema surge ao importar uma polilinha DXF porque a contagem de pontos é truncada para um valor de 16 bits durante o dimensionamento do buffer, enquanto a contagem total é usada para preenchê-lo. Consequentemente, polilinhas com uma contagem de pontos que excede a faixa de 16 bits são gravadas além do final do buffer.

Um erro de heap use-after-free ocorre durante a importação de caracteres de largura em branco em um formato de número ODF. Isso acontece porque um valor de posição lido do documento não é validado em relação ao comprimento da string de código de formato, permitindo que um formato de número malformado seja processado contra a memória fora dos limites da string pretendida. Heap use-after-free é um problema de corrupção de memória onde um programa continua a usar um ponteiro após a memória para a qual ele aponta ter sido liberada.

Um estouro de buffer de heap ocorre durante a importação de gráficos EMF+, que podem estar incorporados em documentos. Especificamente, o problema surge ao importar um pincel de gradiente EMF+. O software lê o número de pontos de mistura de gradiente do arquivo para calcular o tamanho da alocação; no entanto, essa multiplicação pode ocorrer um estouro. Isso resulta na alocação de um buffer pequeno demais, que é então preenchido como se fosse maior, levando a gravação de dados além do limite do buffer.

Um estouro de buffer de heap ocorre durante a importação de documentos no formato OOXML (DOCX). O problema surge ao reproduzir eventos de parser adiados para um elemento de caixa de texto, onde um objeto manipulador é assumido como sendo de um tipo específico e gravado de acordo com o layout de campo desse tipo. Se o objeto for menor do que o assumido, a operação de gravação ultrapassa o final da alocação de memória.

Um estouro de buffer de pilha (stack buffer overflow) ocorre ao importar apresentações no formato binário legado PPT. O problema surge durante a importação de um registro de substituição de cores, onde duas tabelas de cores de tamanho fixo são preenchidas a partir do arquivo. Como a posição de gravação não é redefinida entre as duas passagens pelo registro, um arquivo cujas contagens de cores combinadas excedam o tamanho da tabela grava além do final das tabelas na pilha.

Um estouro de buffer de heap ocorre durante a compilação de fórmulas de células ao abrir uma planilha. Este problema é desencadeado por fórmulas muito longas que contêm inúmeros tokens de abertura. A matriz usada para rastrear a profundidade do aninhamento é alocada com um elemento a menos para o pior cenário, fazendo com que a fórmula escreva um elemento além do limite da matriz.

Um estouro de buffer de heap ocorre durante a importação de alterações rastreadas de um documento de planilha. Isso acontece quando um documento reutiliza o mesmo identificador de alteração para dois tipos diferentes de alterações, fazendo com que o importador trate um objeto de alteração como um tipo maior e escreva dados além do limite da memória alocada.

Um problema de gravação fora dos limites (out-of-bounds write) existe no transporte virtio PCI nas arquiteturas x86 64 e aarch64. Um usuário local do convidado com privilégios de root pode explorar isso modificando os registradores de configuração de fila virtio após a ativação do dispositivo para travar o processo VMM do Firecracker ou potencialmente executar código arbitrário no host. A execução de código no host requer pré-condições adicionais, como configurações de snapshot específicas ou o uso de um kernel de convidado personalizado.