Arjun Basnet

A neutralização inadequada de elementos especiais no gerenciador de configuração SSH localizado em `client/ssh/config/manager.go` permite que um peer malicioso ou comprometido execute comandos arbitrários em outros hosts clientes. O cliente cria um arquivo drop-in do OpenSSH de todo o sistema (como `/etc/ssh/ssh config.d/99-netbird.conf` ou `%PROGRAMDATA%sshssh config.d` no Windows) que incorpora FQDNs ou nomes de host de peers dentro de uma diretiva Match host entre aspas duplas sem a devida filtragem. Um nome de peer contendo aspas duplas pode quebrar o contexto citado e injetar diretivas de configuração SSH arbitrárias, incluindo comandos `exec`, que são executados localmente como qualquer usuário no host na próxima vez que esse usuário executar o ssh. Isso afeta clientes desktop no Linux, macOS, Windows e FreeBSD.

Ocorre uma gravação fora dos limites do heap na função `BoltReadHandler()` em `src/bolt/bolt api.c`. Um invasor remoto não autenticado pode desencadear isso enviando uma mensagem Bolt RESET com um tamanho de chunk personalizado para a porta Bolt. O problema ocorre porque o tamanho é validado usando `ASSERT()`, que é removido em compilações de release. Isso permite que o sistema compute um ponteiro de destino com base em um tamanho de 16 bits fornecido via rede, movendo potencialmente dados bufferizados em até 64 KiB antes do início do buffer de leitura. Isso pode resultar em negação de serviço ou execução de código arbitrário. Apenas implantações com o endpoint Bolt habilitado via `BOLT PORT` são afetadas.

Um problema de autenticação inadequada existe na função `is authenticated()` (src/bolt/bolt api.c). A função determina se uma senha é necessária enviando um comando AUTH vazio para o Redis. Ela trata incorretamente apenas o erro WRONGPASS como uma indicação de que a autenticação é necessária. Outros erros, como LOADING (ocorrendo durante o carregamento de um conjunto de dados), MASTERDOWN (ocorrendo durante a falha de replicação) ou OOM (Out of Memory - falta de memória), resultam no cliente sendo tratado como autenticado. Isso permite que um invasor remoto não autenticado execute consultas de grafo sem credenciais através do endpoint Bolt. Este problema afeta apenas implantações onde o endpoint Bolt está habilitado via `BOLT PORT`.

Um problema de confusão de tipos existe na função ` read flags()` (src/commands/cmd dispatcher.c). Um atacante remoto autenticado com permissões para executar `GRAPH.QUERY` pode disparar isso ao fornecer um argumento `--bolt`. O sistema converte um objeto de string Redis para uma estrutura de cliente Bolt sem verificar sua origem, levando à desreferenciação de ponteiros lidos desse objeto. Isso pode resultar em negação de serviço, corrupção de memória ou divulgação de memória. Este problema persiste mesmo se o endpoint Bolt estiver desativado, afetando configurações padrão.

Uma gravação fora dos limites do heap (heap-based out-of-bounds write) existe na função `ws read frame()` (src/bolt/ws.c) e na função `buffer apply mask()` (src/bolt/buffer.c). Um atacante remoto não autenticado pode causar a negação de serviço ou corromper a memória do heap enviando um frame WebSocket com um comprimento de carga útil estendido de 64 bits para a porta Bolt. Como o comprimento da carga útil não é limitado e a verificação de limites em `buffer apply mask()` é um ASSERT() que é removido em compilações de lançamento, a função realiza a operação XOR em memória além do buffer de recebimento usando uma chave de máscara fornecida pelo atacante. Este problema afeta apenas implantações onde o endpoint Bolt `BOLT PORT` está habilitado.

Um problema de double free e use-after-free existe na função `RdbLoadDeletedNodes()` dos decodificadores de grafo RDB. Um invasor remoto capaz de emitir comandos de replicação Redis pode causar a negação de serviço ou executar código arbitrário no processo redis-server. Isso ocorre quando um fluxo RDB manipulado é fornecido onde o comprimento do buffer de nós excluídos não é um múltiplo de `sizeof(NodeID)`. Como a verificação de comprimento utiliza `ASSERT()`, que é removido em compilações de release, o sistema prossegue para liberar o buffer, lê-lo e, em seguida, liberá-lo novamente.

Ocorre uma leitura fora dos limites do heap na função `BufferSerializerIOv2 ReadBuffer()` em `src/serializers/serializer io.c`. Um invasor remoto capaz de emitir comandos de replicação Redis pode desencadear isso ao fornecer um fluxo RDB manipulado no qual o campo de comprimento do sub-buffer é maior que o tamanho do buffer restante. Como a verificação de limites depende de um `ASSERT()` que é removido em compilações de lançamento, a função `memcpy()` lê além da memória alocada no heap, podendo levar a uma negação de serviço ou à divulgação de memória do heap.

Um estouro de buffer baseado em pilha ocorre na função ` RdbLoadEntity()` dos decodificadores de grafo RDB. Um invasor remoto capaz de emitir comandos de replicação Redis pode disparar este problema fornecendo um fluxo RDB especialmente criado contendo uma contagem de propriedades de entidade controlada. Essa contagem é usada para dimensionar dois arrays de comprimento variável na pilha da thread sem um limite superior, que o decodificador então preenche com valores fornecidos pelo invasor. Isso pode resultar em negação de serviço ou na execução de código arbitrário.

Recursão não controlada no analisador XML integrado (ofstd/libsrc/ofxml.cc) pode levar a uma negação de serviço, resultando em exaustão de pilha e falha do processo. Isso ocorre quando o analisador processa um documento XML manipulado contendo elementos profundamente aninhados. O problema é acessível através da ferramenta `dcmencap` durante a encapsulação de documentos CDA, ou por qualquer aplicação que utilize as funções `parseFile()` ou `parseString()` de `OFXMLParser` com entradas não confiáveis. As funções vulneráveis específicas são `ParseXMLElement()` e `emptyTheNode()` dentro de `XMLNode`.

Uma leitura global fora dos limites ocorre no decodificador Huffman das bibliotecas IJG JPEG integradas (dcmjpeg/libijg8, libijg12 e libijg16). Isso acontece ao processar um arquivo DICOM contendo um fluxo JPEG manipulado onde a tabela Huffman define uma categoria de diferença superior a 15. Como os valores dos símbolos Huffman não são verificados por padrão, um invasor pode ler a memória além das tabelas `extend test[]` e `extend offset[]`, resultando em falha do sistema ou dados de pixel decodificados incorretamente. Isso afeta o dcmdjpeg e qualquer aplicativo que utilize o DCMTK para descompactar imagens DICOM JPEG.

Recursão não controlada nas funções `DcmSequenceOfItems::read()` e `DcmItem::read()` na biblioteca dcmdata permite que um invasor remoto não autenticado cause a negação de serviço, resultando em exaustão de pilha e falha do processo. Isso ocorre quando o software processa um conjunto de dados DICOM contendo sequências profundamente aninhadas (elementos SQ). O problema afeta serviços que analisam conjuntos de dados antes da autenticação, como aqueles que utilizam solicitações C-STORE no storescp, dcmrecv e dcmqrscp, bem como ferramentas locais como dcmdump ao abrir um arquivo malicioso.

Um problema de leitura fora dos limites (out-of-bounds read) existe no decodificador ZRLE. Um servidor VNC malicioso ou comprometido pode disparar isso enviando tiles codificados em ZRLE com índices de paleta que excedem o tamanho da paleta declarado. As funções `readPaletteRleTile()` e `readPackedPaletteTile()` usam o índice fornecido pelo invasor para procurar cores sem validá-lo em relação ao tamanho da paleta. Isso resulta na cópia de dados do heap fora dos limites para o framebuffer, causando uma exibição distorcida ou causando uma falha de leitura que encerra o visualizador.

Uma atribuição incorreta de permissões permite que um usuário local autenticado leia ou sobrescreva os handles de comunicação inter-processos (IPC) usados entre o serviço TightVNC e seu processo de servidor de desktop. O segmento de memória compartilhada nomeado no namespace Global, que transporta os valores de HANDLE do pipe, é criado com um NULL DACL (Lista de Controle de Acesso Discricionário), o que significa que carece de restrições de acesso. Além disso, o nome do segmento é derivado de um valor `srand(time(0))` baseado no tempo, tornando-o previsível com granularidade de um segundo. Um processo local de baixo privilégio pode abrir esse mapeamento e adulterar o canal IPC de um serviço executado como SYSTEM, levando potencialmente à divulgação de dados de sessão, escalonamento de privilégios ou negação de serviço.

Uma desreferenciação de ponteiro NULL no componente Win8ScreenDriver permite que um invasor cause a falha do servidor, resultando em uma negação de serviço. Isso ocorre quando a reinicialização do driver DXGI Desktop Duplication falha na função `applyNewScreenProperties()`, como após um reset de GPU, hot-plug de monitor ou alteração de sessão. Consequentemente, a variável `m drvImpl` permanece como NULL e é desreferenciada sem verificação pelas funções `executeDetection()`, `getScreenBuffer()`, `grabFb()`, `getScreenPropertiesChanged()` e `getCursorPosition()`.

Ocorre uma recursão mútua não controlada entre as funções `parseDataSet()`, `parseElement()` e `parseSequence()` dentro da classe `DcmJSONReader`. Um invasor pode causar a negação de serviço, resultando em exaustão de pilha e falha do processo, ao fornecer um documento DICOM JSON especialmente criado com valores de sequência (SQ) profundamente aninhados. Este problema afeta a ferramenta `json2dcm` e qualquer serviço que utilize este leitor para converter DICOM JSON não confiável, como payloads DICOMweb.

Uma recursão mútua não controlada entre as funções `parseDataSet()` e `parseSequence()` no conversor XML-para-DICOM (dcmdata/libdcxml/xml2dcm.cc) pode levar a uma negação de serviço. Um invasor pode causar o esgotamento da pilha (stack exhaustion) e a falha do processo através de um arquivo XML manipulado com elementos de sequência e item profundamente aninhados. Isso afeta a ferramenta `xml2dcm` e qualquer serviço que utilize este código para converter XML não confiável para DICOM.

Recursão não controlada na função `moveRecordToTree()` em dcmdata/libsrc/dcdicdir.cc pode levar a uma negação de serviço caracterizada por exaustão de pilha e falha no processo. Isso ocorre quando um invasor fornece um arquivo DICOMDIR especialmente criado contendo uma sequência profundamente encadeada de registros de diretório vinculados através do atributo `Offset of Referenced Lower-Level Directory Entity`. Qualquer aplicativo que abra o DICOMDIR, como o dcmgpdir ou visualizadores de mídia baseados no DCMTK, está suscetível a este problema.

Um usuário local autenticado pode executar código arbitrário com privilégios de SYSTEM devido a um elemento de caminho de pesquisa não controlado. A função `DynamicLibrary::init()` (e ThemeLib) utiliza `LoadLibrary()` para carregar screenhooks32.dll e screenhooks64.dll usando um nome de arquivo simples e sem as flags `LOAD LIBRARY SEARCH *`. Isso faz com que o serviço siga a ordem de pesquisa de DLL padrão, permitindo o carregamento de uma DLL maliciosa colocada por um invasor em um diretório gravável que apareça anteriormente na sequência de pesquisa, como um diretório de instalação com Listas de Controle de Acesso (ACLs) permissivas.

Ocorre um underflow de número inteiro na função `trimTransparent()` dentro de `WinCursorShapeUtils` quando um formato de cursor com largura ou altura zero é processado no caminho de captura DXGI. Isso permite que um usuário local autenticado cause a falha do servidor e, potencialmente, leia memória fora dos limites. O problema surge porque o limite do loop `width - 1` envolve para 0xFFFFFFFF, resultando em um acesso à memória aproximadamente 4 GB além do buffer de cursor de 64 KB. Além disso, um cursor monocromático com altura 1 torna-se 0 porque a função `getCursorHeight()` reduz a altura pela metade no local.

Existe uma leitura fora dos limites baseada em heap na função `decodeFrame()` em `dcmdata/libsrc/dcrleccd.cc`. Isso ocorre ao processar um arquivo DICOM RLE Lossless manipulado onde o fragmento de dados de pixel é menor que o cabeçalho RLE de 64 bytes, permitindo que um invasor leia até 63 bytes da memória heap adjacente ou cause um travamento. O problema decorre do fato de a função copiar 64 bytes sem verificar o comprimento do fragmento. Aplicativos que decodificam imagens RLE quadro a quadro, como aqueles que usam a função `getUncompressedFrame()` em `DcmPixelData`, são afetados.