Theodosis Paidakis

Um problema de autorização inadequada existe na lógica de exclusão de push. O sistema compara `@push.user` com `current user`; quando um push é criado anonimamente, ambos os valores são nil. Como o Ruby avalia `nil == nil` como verdadeiro, a verificação de propriedade é aprovada, ignorando a restrição `deletable by viewer`. Isso permite que um invasor que conheça a URL secreta exclua permanentemente um push anônimo, mesmo que o criador tenha desativado a exclusão pelo visualizador ou que uma senha fosse necessária. Este problema afeta apenas implantações que permitem pushes anônimos.

Uma falha no componente Session Cookie Handler permite a autenticação inadequada por meio de manipulação remota. O problema reside na função `std::strncmp()` dentro do arquivo `src/tsessioncookiestore.cpp`. Este ataque é caracterizado por alta complexidade e dificuldade de exploração.

Um usuário autenticado pode causar exaustão de recursos ao enviar solicitações para o endpoint 'GET /loading' usando um parâmetro de consulta `id` malicioso. O problema ocorre porque o manipulador não realiza uma verificação de validade de busca em mapa e tenta receber dados de um canal nulo (um canal que não foi inicializado), o que bloqueia a execução indefinidamente. Devido à ausência de tempos limite (timeouts), cancelamento de contexto e recuperação do lado do servidor, cada solicitação consome permanentemente uma goroutine (uma thread leve gerenciada pelo runtime do Go), um descritor de arquivo e aproximadamente 50 kB de memória. Isso continua até que o servidor atinja seu limite de descritores de arquivo, fazendo com que as chamadas Accept do listener falhem e interrompam todo o encaminhamento de tráfego de túnel para todos os usuários.

Usuários autenticados de baixo privilégio com permissões de criação de túnel podem realizar uma injeção de nova linha. Ao fornecer um caractere de nova linha codificado em percentual no parâmetro `domain` do endpoint de criação de túnel, um invasor pode injetar linhas arbitrárias no arquivo SSH authorized keys da conta do servidor. Isso permite a inserção de uma chave pública irrestrita para obter acesso persistente ao shell, permitindo que o invasor leia credenciais em texto claro do arquivo de banco de dados, incluindo todos os tokens de usuário, chaves privadas de túnel e certificados TLS.

Detentores de chaves de API autenticadas podem desencadear server-side request forgery (SSRF), uma falha na qual o servidor é coagido a fazer requisições não autorizadas. Ao fornecer uma URL longa manipulada durante o processo de criação de URL curta com a resolução automática de título ativada, um invasor pode forçar o servidor a emitir requisições HTTP GET arbitrárias. Isso pode ser alcançado utilizando hosts públicos que redirecionam para alvos internos, como endereços de loopback, intervalos de link-local ou endpoints de metadados de nuvem, como 169.254.169.254. Informações de serviços internos podem então ser exfiltradas através do elemento de título HTML retornado na resposta de criação da URL curta.

Um detentor de chave de API autenticado pode realizar uma injeção de SQL cega ao fornecer um valor não validado no parâmetro de consulta `orderBy` do endpoint de estatísticas de tags. Isso ocorre porque a entrada flui sem sanitização para uma cláusula ORDER BY do Doctrine QueryBuilder, permitindo a injeção de fragmentos SQL arbitrários. Isso pode levar à extração de dados sensíveis de qualquer locatário, incluindo URLs longas, registros de visitantes, endereços IP, dados de geolocalização, agentes de usuário e segredos de chaves de API hashed, utilizando técnicas baseadas em tempo, oráculo booleano ou erro.

Existe um problema onde invasores remotos não autenticados podem injetar fórmulas de planilhas em dados de visita exportados. Ao enviar uma requisição para qualquer URL curta com valores maliciosos nos cabeçalhos `User-Agent`, `Referer` ou no caminho da requisição começando com caracteres como `=`, `+`, `-` ou `@`, invasores podem incorporar payloads de fórmulas DDE (Dynamic Data Exchange) ou WEBSERVICE. Esses payloads são executados na máquina de um administrador quando o arquivo CSV exportado é aberto em um aplicativo de planilha que avalia fórmulas.

Um problema de cross-site scripting armazenado existe que permite que atacantes remotos não autenticados executem JavaScript arbitrário na sessão do navegador de um administrador. Isso ocorre quando marcações HTML são injetadas em mensagens de transcrição de agentes processadas através da API de sessões. Atacantes podem usar payloads de manipuladores de eventos inline, como uma tag `img` com um atributo `onerror`, dentro de um limite de 60 caracteres. O payload é armazenado na transcrição da sessão e interpolado sem sanitização no `innerHTML` da página inicial padrão. Isso pode levar ao roubo de tokens de sessão e chamadas não autorizadas a endpoints administrativos autenticados, incluindo a modificação de arquivos de instrução do agente.

Um problema de cross-site scripting armazenado existe onde atacantes remotos não autenticados podem injetar payloads arbitrários de HTML e script. Isso ocorre quando um nome de usuário manipulado é enviado em uma requisição POST de login malsucedida, que é então registrada literalmente no log de auditoria. Quando um administrador abre o painel de notificações, a entrada do log é renderizada usando innerHTML. Devido a uma Content-Security-Policy (uma camada de segurança que ajuda a detectar e mitigar certos tipos de ataques) permissiva que permite manipuladores de eventos inline, o payload é executado na sessão do administrador. Isso permite que o atacante interaja com endpoints autenticados, como a edição de arquivos de instrução de agentes e a modificação de configurações.

Um problema de HTTP request smuggling existe devido ao encaminhamento inadequado de cabeçalhos na implementação do proxy localizada em `src/proxy.rs`. O proxy encaminha o cabeçalho `Transfer-Encoding` do cliente para os backends upstream sem modificações, embora o corpo da requisição já tenha sido desfragmentado (de-chunked) pelo `tiny http`. Isso permite ataques de dessincronização CL.TE, nos quais um invasor remoto pode manipular os limites das mensagens HTTP para controlar onde o servidor backend acredita que o corpo da requisição termina.

Um problema de HTTP request smuggling existe onde atacantes remotos podem ignorar controles de acesso injetando caracteres de quebra de linha simples (0x0A) em valores de cabeçalho de requisição fornecidos pelo cliente. Esses valores são copiados integralmente para conexões upstream sem validação. Isso permite que um atacante crie um valor de cabeçalho contendo uma requisição HTTP adicional completa que backends, como Go net/http e Python http.server, interpretam como uma requisição separada. Consequentemente, o backend processa uma requisição contrabandeada com método, caminho e cabeçalhos escolhidos pelo atacante, ignorando a lógica de controle de acesso do manipulador rouille.

Um invasor remoto não autenticado pode travar processos trabalhadores ao enviar uma linha de requisição HTTP malformada contendo uma string de versão inválida. A função `HttpParser::execute()` falha ao alocar o objeto `Url` quando a análise da versão falha, deixando o ponteiro `url` como NULL. Subsequentemente, a função `buildResponse()` desreferencia este ponteiro NULL sem verificar a flag `valid requ`, resultando em um SIGSEGV (uma falha de segmentação que ocorre quando um programa tenta acessar um local de memória ao qual não tem permissão). Se esta ação for repetida em todos os processos trabalhadores, o servidor permanecerá offline até que seja reiniciado manualmente.

Um problema permite que atacantes não autenticados leiam arquivos arbitrários ao enviar sequências `../` no caminho da URL. Essas sequências são concatenadas diretamente à raiz web configurada na função `buildResponse()` do `HttpBuilder` sem normalização, remoção de segmentos de ponto ou verificações de limite. Atacantes podem criar requisições que passam pelo analisador de URL inalteradas e atingem a chamada do sistema de arquivos via função `setFile()` do `HttpFile`, expondo potencialmente arquivos sensíveis, como armazenamentos de credenciais e chaves privadas, caso o processo do servidor seja executado como root.

Atacantes não autenticados podem esgotar a memória disponível enviando requisições HTTP bem formadas. Isso ocorre porque a função `HttpParser::execute()` aloca objetos `Url`, objetos `HttpHeaders` e instâncias `HttpHeader` usando expressões new brutas que nunca são liberadas devido a destrutores ausentes e chamadas delete inacessíveis. Consequentemente, a memória residente do worker aumenta aproximadamente 20 a 28 kB por requisição até que o processo do worker seja encerrado.

Existe um problema de divisão de resposta HTTP (HTTP response splitting) onde atacantes remotos podem injetar cabeçalhos de resposta arbitrários ao inserir bytes de retorno de carro (0x0D) ou alimentação de linha (0x0A) em entradas sob seu controle. Isso pode ocorrer por meio de parâmetros de consulta decodificados em percentual que são refletidos nos cabeçalhos de resposta ou ao injetar caracteres de alimentação de linha em valores de cabeçalho de Cookie que são interpolados diretamente nos cabeçalhos de resposta Set-Cookie. Tais ações podem levar ao envenenamento de cache, fixação de sessão e a anulação de cabeçalhos de segurança, o que pode permitir que atacantes ignorem as políticas de Content Security Policy (CSP) ou Cross-Origin Resource Sharing (CORS).

Um problema de execução remota de código autenticado existe onde usuários com permissões de gerenciamento de `custom fields` podem executar código Ruby arbitrário. Isso ocorre quando uma expressão maliciosa é fornecida através do tipo de campo personalizado `select eval`. Um invasor pode armazenar uma expressão Ruby controlada no parâmetro `command` das opções do campo, que é então avaliada via função `instance eval()` dentro de uma view ERB durante a renderização de uma página de edição de postagem. Isso permite a execução de código no servidor com os privilégios do processo do servidor web.

Existe um problema onde atacantes autenticados podem causar a queda do servidor ao fornecer uma string hexadecimal válida de 24 caracteres para o parâmetro `room` que não corresponda a nenhum documento no banco de dados. Isso leva a uma desreferência de ponteiro nulo, resultando em um TypeError não capturado dentro de um callback assíncrono do Mongoose que encerra o processo do servidor Node.js. Esta falha é acessível através do endpoint 'GET /messages' e outros caminhos de código, incluindo a interface socket.io.

Um controle de acesso quebrado permite que atacantes autenticados baixem anexos de arquivos de salas privadas e protegidas por senha das quais não são membros. Isso ocorre porque o sistema falha ao realizar verificações de associação à sala durante a recuperação de arquivos. Um atacante pode enumerar MongoDB ObjectIds adjacentes—identificadores únicos usados pelo MongoDB para referenciar documentos—derivados de um ID de arquivo conhecido para recuperar arquivos enviados por outros usuários. O problema reside no endpoint `GET /files/:id/:name` em `app/controllers/files.js`, que apenas verifica a autenticação de login e ignora a verificação `Room.canJoin()`.

Um problema de autorização inadequada permite que usuários autenticados arquivem qualquer sala no servidor. Isso ocorre porque o manipulador de salas não verifica a propriedade ao processar uma requisição DELETE. Atacantes podem identificar IDs de salas através do endpoint de listagem de salas para arquivar permanentemente salas privadas ou protegidas por senha que não têm permissão para acessar. Uma vez arquivadas, essas salas não podem ser recuperadas pelo aplicativo, exigindo intervenção direta no banco de dados para a restauração.

Existe um problema onde a biblioteca analisa incorretamente o cabeçalho `Transfer-Encoding`. Ao enviar este cabeçalho com qualquer valor, incluindo codificações não fragmentadas (non-chunked), a biblioteca aplica a decodificação de fragmentos incondicionalmente e ignora o cabeçalho `Content-Length`. Isso cria uma discrepância entre a biblioteca e um proxy de front-end implementado corretamente, permitindo que atacantes remotos dessincronizem o enquadramento de requisições e realizem o contrabando de requisições (request smuggling). Além disso, o envio de corpos não fragmentados com valores de `Transfer-Encoding` não fragmentados pode levar a falhas na leitura do corpo, o que consome threads de trabalho e ocupa conexões sem notificar os clientes sobre o erro.