Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
React-Router-CVE-2025-61686- — Análise detalhada de CVE-2025-61686, uma vulnerabilidade de path traversal no armazenamento de sessão em arquivo do React Router, incluindo causa raiz, cenários de ataque e descobertas de auditoria de código. | Kitploit
Ferramentas/GitHubGitHub/kai-one001/react-router-cve-2025-61686-
Análise EstáticaAnálise de VulnerabilidadesAnálise de CódigoExploraçãoSegurança WebAprendizado e Educação
GitHubkai-one001/react-router-cve-2025-61686-

React-Router-CVE-2025-61686-

Análise detalhada de CVE-2025-61686, uma vulnerabilidade de path traversal no armazenamento de sessão em arquivo do React Router, incluindo causa raiz, cenários de ataque e descobertas de auditoria de código.

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Ver Repositório
2há 7 mesesAinda não revisado
Compartilhar

Relatório de Análise da Vulnerabilidade CVE-2025-61686

Resumo da Vulnerabilidade

CVE ID: CVE-2025-61686
Versões Afetadas: @react-router/node 7.0.0 a 7.9.3
Tipo de Vulnerabilidade: Path Traversal / Directory Traversal

Princípio da Vulnerabilidade

1. Localização da Vulnerabilidade

A vulnerabilidade existe na função getFile() e na lógica de operações de arquivo relacionadas no arquivo packages/react-router-node/sessions/fileStorage.ts.

2. Análise do Problema Central

2.1 Origem do Session ID

Na linha 267 de packages/react-router/lib/server-runtime/sessions.ts:

root@kitploit:~
async getSession(cookieHeader, options) {
  let id = cookieHeader && (await cookie.parse(cookieHeader, options));
  let data = id && (await readData(id));
  return createSession(data || {}, id || "");
}

O Session ID é analisado a partir do Cookie, através do método cookie.parse().

2.2 Lógica de Decodificação do Cookie

Na função decodeCookieValue() em packages/react-router/lib/server-runtime/cookies.ts:

root@kitploit:~
async function decodeCookieValue(
  value: string,
  secrets: string[],
): Promise<any> {
  if (secrets.length > 0) {
    // Se secrets estiver configurado, a assinatura será verificada
    for (let secret of secrets) {
      let unsignedValue = await unsign(value, secret);
      if (unsignedValue !== false) {
        return decodeData(unsignedValue);
      }
    }
    return null;  // Retorna null se a verificação da assinatura falhar
  }
  
  // Se não houver secrets (não assinado), retorna diretamente o valor decodificado
  return decodeData(value);
}

Problema Central: Quando o cookie não está assinado (secrets é um array vazio ou não definido), decodeCookieValue retorna diretamente o valor do cookie decodificado, permitindo que o atacante controle completamente este valor.

2.3 Lógica de Construção de Caminho

Em packages/react-router-node/sessions/fileStorage.ts:

root@kitploit:~
export function getFile(dir: string, id: string): string {
  // Divide o id da sessão em um diretório (primeiros 2 bytes) e um nome de arquivo
  // (6 bytes restantes) para reduzir a chance de diretórios muito grandes,
  return path.join(dir, id.slice(0, 4), id.slice(4));
}

Esta função divide o Session ID em duas partes:

  • Primeiros 4 caracteres como nome do diretório: id.slice(0, 4)
  • Caracteres restantes como nome do arquivo: id.slice(4)

Em seguida, usa path.join() para concatenar o caminho.

2.4 Forma de Exploração da Vulnerabilidade

Cenário de Ataque: Ao usar createFileSessionStorage() com cookie não assinado:

  1. O atacante pode construir um session ID malicioso, por exemplo: ../../etc/passwd
  2. Processamento da função getFile():
    • id.slice(0, 4) = ../.
    • id.slice(4) = /etc/passwd
    • path.join(dir, ../., /etc/passwd)
    • Embora path.join() normalize o caminho, se dir já for um caminho relativo ou após processamento, ainda pode ser possível realizar path traversal

Uma forma mais precisa de exploração:

  • Session ID: ....//etc/passwd
    • id.slice(0, 4) = ....
    • id.slice(4) = //etc/passwd
    • Se tratado incorretamente, pode levar ao acesso a /etc/passwd

Ou:

  • Session ID: ../../../etc/passwd (16 caracteres)
    • id.slice(0, 4) = ../.
    • id.slice(4) = ./etc/passwd
    • Combinado com o comportamento de path.join(), pode resultar em path traversal

3. Operações Afetadas

As seguintes operações de arquivo podem ser afetadas:

  1. readData(id) - Ao ler dados da sessão

    root@kitploit:~
    async readData(id) {
      try {
        let file = getFile(dir, id);
        let content = JSON.parse(await fsp.readFile(file, "utf-8"));
        // ...
      }
    }
    
  2. updateData(id, data, expires) - Ao atualizar dados da sessão

    root@kitploit:~
    async updateData(id, data, expires) {
      let content = JSON.stringify({ data, expires });
      let file = getFile(dir, id);
      await fsp.mkdir(path.dirname(file), { recursive: true });
      await fsp.writeFile(file, content, "utf-8");
    }
    
  3. deleteData(id) - Ao excluir dados da sessão

    root@kitploit:~
    async deleteData(id) {
      try {
        await fsp.unlink(getFile(dir, id));
      }
    }
    

4. Impacto do Ataque

  1. Leitura de Arquivos: O atacante pode ler arquivos arbitrários no servidor (dependendo das permissões do processo do servidor web)
  2. Escrita de Arquivos: O atacante pode escrever arquivos no servidor, o que pode levar a:
    • Vazamento de dados
    • Injeção de código
    • Escalação de privilégios
  3. Exclusão de Arquivos: O atacante pode excluir arquivos no servidor

5. Condições para Exploração da Vulnerabilidade

Todas as seguintes condições devem ser atendidas simultaneamente:

  1. Utilizar o método createFileSessionStorage()
  2. Cookie não assinado (a configuração do cookie não possui secrets definido ou secrets é um array vazio)
  3. O processo do servidor web possui permissões de leitura e escrita no arquivo alvo

Descobertas da Auditoria de Código

Caminho Crítico do Código

root@kitploit:~
getSession(cookieHeader) 
  → cookie.parse(cookieHeader) 
    → decodeCookieValue(value, secrets)  // Retorna diretamente o value quando não assinado
      → readData(id) 
        → getFile(dir, id)  // Concatenação de caminho, risco de path traversal
          → fsp.readFile(file) / fsp.writeFile(file) / fsp.unlink(file)

Causa Raiz do Problema

  1. Falta de validação de entrada: A função getFile() não valida ou normaliza o parâmetro id
  2. Dependência da normalização do path.join(): Embora path.join() normalize o caminho, em situações específicas (como quando o caminho anterior já contém ..) ainda pode permitir path traversal
  3. Cookie não assinado: Permite que o atacante controle completamente o valor do Session ID
Baixar ferramenta