Mingkai Yu

O SGLang com o backend de desagregação Mooncake permite a negação de serviço ao aceitar mensagens de registro de decodificação não autenticadas no socket ZMQ PULL do rank Prefill. Atacantes adjacentes à rede podem esgotar a memória do Prefill, levando ao encerramento do agendador por OOM-killed (Out-Of-Memory killed, um processo onde o sistema operacional encerra um processo para liberar memória), enviando inúmeros registros contendo frames de buffer aninhados grandes e valores `mooncake session id` exclusivos.

No modo de desagregação prefill/decode, existe um problema de server-side request forgery que permite que atacantes não autenticados desencadeiem solicitações externas. Ao enviar solicitações manipuladas para o endpoint '/generate' do Decode worker, os atacantes podem usar os campos `bootstrap host` e `bootstrap port` para sondar hosts e portas internos. Esta ação pode bloquear o loop do agendador compartilhado, resultando em atrasos para outras solicitações de inferência.

Um problema de alocação de memória não controlada existe no backend de desagregação Mooncake, dentro da função `handle staging rsp()`. Atacantes adjacentes à rede não autenticados podem esgotar a memória de Prefill ao obter o endereço de rank através do endpoint '/route' e enviar mensagens STAGING RSP com valores de `chunk idx` excessivamente grandes sob novos IDs de sala. Esta ação pode levar ao encerramento do agendador por OOM-killed, que se refere a um estado de falta de memória (Out-Of-Memory) onde o sistema operacional encerra o processo para recuperar memória.

Um problema de negação de serviço existe onde clientes de API podem abortar solicitações de geração em andamento pertencentes a outros usuários. Isso ocorre quando um invasor envia solicitações de streaming para o endpoint '/generate' usando um `rid` (identificador de solicitação) curto e controlado pelo cliente. Ao usar valores de `rid` de um único caractere hexadecimal e depois desconectar, o invasor aciona a lógica de aborto por correspondência de prefixo que encerra todas as outras solicitações de clientes ativos.

Existe uma falha de bypass de autorização que permite que detentores da chave de API do data-plane acessem rotas de gerenciamento de Alta Disponibilidade (HA) da malha. Isso ocorre porque os endpoints `/ha/*` ignoram as verificações de função de Administrador do control-plane. Um invasor pode ler a topologia do cluster, gravar configurações propagadas, alterar limites globais de taxa e utilizar o endpoint `POST /ha/shutdown` para dissolver silenciosamente a coordenação de HA.

O software confia em valores `mm hashes` fornecidos pelo chamador como a chave de cache de prefixo multimodal. Isso permite que atacantes remotos envenenem entradas de cache KV (Chave-Valor) entre requisições. Ao enviar uma imagem diferente sob um hash conhecido ou previsto através do endpoint '/generate', um atacante pode expor o conteúdo da imagem de outra requisição ou corromper as respostas recebidas pelas vítimas.

Um invasor não autenticado pode causar a negação de serviço enviando uma solicitação para o endpoint '/generate' contendo o campo `pd kv trans params`. Isso desencadeia uma falha na função `pickle.loads` dentro de `InferSamplingParams`, que interrompe a thread de inferência. Embora o endpoint '/health' permaneça operacional, todas as solicitações subsequentes ficarão travadas até que o sistema seja reiniciado.

O servidor HTTP em modo multiprocessado carece de autenticação, permitindo que atacantes remotos não autenticados acessem endpoints de gerenciamento que ouvem em todas as interfaces por padrão. Isso permite que atacantes leiam credenciais de ambiente através do endpoint 'GET /env' e configurações através do endpoint 'GET /config'. Além disso, atacantes podem limpar caches, excluir objetos de cache e modificar cotas de locatários para excluir dados em cache de outros locatários.

Um problema de execução remota de código não autenticada existe onde invasores remotos podem executar código Python enviando scripts para o endpoint '/run script'. Ao utilizar o objeto de aplicativo FastAPI injetado, os invasores podem recuperar builtins reais para ignorar a função ` import ` protegida, permitindo a importação do módulo `os` e a execução de comandos do sistema operacional com os privilégios do processo LMCache.

O serviço de monitoramento de frontend contém um problema de server-side request forgery (SSRF). Atacantes não autenticados podem ignorar a lista de permissões do proxy registrando hosts arbitrários através do endpoint 'POST /api/proxies'. Subsequentemente, os endpoints '/proxy' ou '/proxy2' podem ser usados para acessar hosts internos, ler respostas, adulterar nós ou interromper o heartbeat.

O coordenador multiprocessado carece de autenticação, permitindo que atacantes remotos não autenticados acessem a API de controle de frota HTTP, que escuta em todas as interfaces por padrão. Atacantes podem usar o endpoint '/instances' para registrar ou desregistrar instâncias, o endpoint '/quota' para sobrescrever cotas e o endpoint '/events' para injetar eventos. Além disso, podem enumerar '/directory/keys' para divulgar metadados de posicionamento e interromper o cache.

Uma falha de autenticação ausente permite que atacantes não autenticados excluam objetos forçadamente através da porta `coro rpc`. Ao enviar solicitações forjadas com a flag `force` ativada, atacantes podem ignorar verificações de concessão (lease checks) e utilizar as funções `Remove()`, `RemoveByRegex()`, `RemoveAll()` e `BatchRemove()` para apagar chaves que correspondam a qualquer regex ou limpar toda a loja, resultando em perda de cache e falhas de requisição.

O serviço Store REST vincula-se ao 0.0.0.0 sem autenticação em qualquer rota. Isso permite que atacantes não autenticados acessem os seguintes endpoints de API: '/api/get', '/api/put', '/api/remove all' e '/api/mount'. Através desses endpoints, um atacante pode ler dados de cache KV (Chave-Valor), injetar ou excluir objetos e montar segmentos descritos pelo atacante.

Uma falha de autorização ausente permite que atacantes não autenticados manipulem tarefas de replicação através da porta `coro rpc`. Ao utilizar UUIDs de clientes vítimas obtidos através da função `QueryTask()`, atacantes podem invocar `CreateCopyTask()`, `CreateMoveTask()`, `FetchTasks()` e `MarkTaskToComplete()` para sequestrar filas de tarefas e registrar falsamente atividades de replicação.

Uma falha de autorização ausente permite que atacantes não autenticados injetem réplicas LOCAL DISK concluídas por meio do RPC `NotifyOffloadSuccess`. Ao montar um segmento de disco local com um UUID de cliente escolhido, um atacante pode anexar réplicas que apontam para endpoints sob seu controle. Isso possibilita a entrega de leituras de camada de disco envenenadas e a simulação de existência de chaves falsas.

Uma falha de autorização ausente permite que atacantes não autenticados apaguem réplicas em disco de qualquer objeto. Ao acessar a porta master `coro rpc`, um atacante pode acionar as funções `EvictDiskReplica()` e `BatchEvictDiskReplica()` para remover réplicas de DISK em todos os locatários. Isso pode resultar na exclusão permanente de objetos caso a réplica em disco fosse a única cópia restante.

Ocorre uma leitura fora dos limites (out-of-bounds read) na função `readString()` em include/common.h. Isso permite que atacantes não autenticados causem a interrupção do serviço, como um servidor de inferência SGLang, ao se conectarem à porta de handshake e enviarem um frame de handshake de comprimento zero composto por oito bytes.

O servidor de metadados HTTP contém uma falha de autenticação ausente no endpoint '/metadata'. Isso permite que atacantes não autenticados leiam, sobrescrevam e excluam chaves de metadados do mecanismo de transferência. A exploração pode levar ao envenenamento de descritores de segmento, como `tcp data port`, ou à recriação de entradas `rpc meta` para redirecionar transferências de cache KV para ouvintes controlados pelo atacante. Além disso, este problema pode ser usado para esgotar a memória do servidor.

Existe um desreferenciamento de ponteiro não confiável na função `readHeader` de `ServerSession`. Isso permite que atacantes não autenticados leiam e escrevam na memória arbitrária do processo através da porta de dados de transporte TCP. Ao enviar um `SessionHeader` manipulado contendo valores arbitrários de `addr` e `size` usando opcodes READ ou WRITE, um atacante pode expor conteúdos de cache KV, prompts e segredos, ou corromper a memória para alcançar a execução de código.

Um invasor não autenticado pode causar exaustão de memória enviando frames de notificação repetidamente, cada um com até 1 MB, para a porta RPC de handshake. Esse processo preenche o vetor `notifys` sem limite dentro da função `TransferMetadata::receivePeerNotify()`, levando ao crescimento ilimitado da memória do processo até que o eliminador de falta de memória (out-of-memory killer) encerre o mecanismo.