Introdução
Curl é uma ferramenta de linha de comando poderosa que permite transferir dados usando vários protocolos, incluindo HTTP, FTP e SFTP. Neste tutorial, você aprenderá como usar Curl para acessar diferentes portas em seu servidor ou rede, permitindo que você solucione problemas de conectividade e teste a disponibilidade de portas.
Este laboratório prático irá guiá-lo através de comandos Curl básicos e avançados para acesso a portas, ajudando você a entender como os serviços de rede operam em diferentes portas. Ao final deste laboratório, você será capaz de usar Curl com confiança para interagir com serviços executados em várias portas.
Começando com Curl
Curl, que significa "Client URL", é uma ferramenta de linha de comando para transferir dados de ou para um servidor. Ele suporta inúmeros protocolos, incluindo HTTP, HTTPS, FTP, SFTP e muitos outros. Antes de mergulhar em operações específicas de portas, vamos garantir que você entenda o uso básico do Curl.
Comando Curl Básico
Abra seu terminal e digite o seguinte comando para verificar se o Curl está instalado em seu sistema:
curl --version
Você deve ver uma saída semelhante a esta, mostrando a versão do Curl e os recursos suportados:
curl 7.81.0 (x86_64-pc-linux-gnu) libcurl/7.81.0 OpenSSL/3.0.2 zlib/1.2.11 brotli/1.0.9 zstd/1.4.8 libidn2/2.3.2 libpsl/0.21.0 (+libidn2/2.3.2) libssh/0.9.6/openssl/zlib nghttp2/1.43.0 librtmp/2.3 OpenLDAP/2.5.13
Release-Date: 2022-01-05
Protocols: dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL TLS-SRP UnixSockets zstd
Agora, vamos tentar uma solicitação Curl simples para um site. Digite o seguinte comando:
curl https://example.com
Este comando baixa o conteúdo HTML de example.com e o exibe em seu terminal. A saída será semelhante a:
<!doctype html>
<html>
<head>
<title>Example Domain</title>
<!-- More HTML content -->
</head>
<body>
<div>
<h1>Example Domain</h1>
<p>This domain is for use in illustrative examples in documents...</p>
<!-- More HTML content -->
</div>
</body>
</html>
Entendendo as Portas HTTP
Servidores web normalmente são executados em portas específicas:
- Porta 80 para HTTP (não seguro)
- Porta 443 para HTTPS (seguro)
Quando você acessa um site sem especificar uma porta, seu navegador usa automaticamente essas portas padrão. No entanto, com Curl, você pode especificar explicitamente a qual porta se conectar.
Vamos tentar acessar um site na porta HTTP padrão (porta 80):
curl http://example.com:80
A saída deve ser semelhante ao seu comando Curl anterior, pois a porta 80 é a padrão para HTTP.
Agora, tente acessar o mesmo site na porta HTTPS (porta 443):
curl https://example.com:443
Novamente, a saída deve ser semelhante, pois a porta 443 é a padrão para HTTPS.
Nestes exemplos, especificamos explicitamente as portas na URL usando o formato protocolo://domínio:porta. Essa sintaxe é crucial ao trabalhar com serviços em portas não padrão.
Usando Curl com Diferentes Portas
Agora que você entende os conceitos básicos do Curl e da especificação de portas, vamos explorar como interagir com diferentes portas.
Acessando Portas Web Não Padrão
Servidores web podem ser executados em portas diferentes de 80 e 443. Para fins de teste, vamos configurar um servidor web simples na porta 8000 usando o servidor HTTP embutido do Python.
Primeiro, crie um arquivo HTML simples para servir:
echo "<html><body><h1>Olá da porta 8000!</h1></body></html>" > ~/project/test.html
Agora, navegue até o diretório contendo o arquivo e inicie um servidor HTTP simples na porta 8000:
cd ~/project
python3 -m http.server 8000 &
O & no final do comando executa o servidor em segundo plano. Você deve ver uma saída como:
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
Agora, use Curl para acessar este servidor na porta 8000:
curl http://localhost:8000/test.html
Você deve ver o conteúdo HTML que criamos:
<html>
<body>
<h1>Olá da porta 8000!</h1>
</body>
</html>
Quando terminarmos com o servidor, podemos pará-lo encontrando seu ID de processo e matando-o:
ps aux | grep "python3 -m http.server"
Isso mostrará uma saída semelhante a:
labex 1234 0.0 0.1 235368 12312 pts/0 S 10:00 0:00 python3 -m http.server 8000
labex 1235 0.0 0.0 12345 1234 pts/0 S+ 10:01 0:00 grep --color=auto python3 -m http.server
Observe o ID do processo (PID) na segunda coluna (1234 neste exemplo) e mate o processo:
kill $(pgrep -f "python3 -m http.server")
Usando Diferentes Métodos HTTP
Curl permite que você especifique diferentes métodos HTTP usando a flag -X. Vamos tentar uma solicitação POST:
curl -X POST http://example.com
Isso envia uma solicitação POST para example.com. A maioria dos sites responderá com uma mensagem indicando que esperam dados diferentes para solicitações POST.
Adicionando Headers às Solicitações
Ao trabalhar com APIs ou serviços específicos, você geralmente precisa enviar headers personalizados. Você pode fazer isso com a flag -H:
curl -H "Content-Type: application/json" http://example.com
Isso envia uma solicitação com um header de tipo de conteúdo JSON. A resposta dependerá de como o servidor lida com este header.
Visualizando Headers de Resposta
Para ver os headers de resposta junto com o conteúdo, use a flag -i:
curl -i http://example.com
Isso mostrará uma saída semelhante a:
HTTP/1.1 200 OK
Content-Encoding: gzip
Accept-Ranges: bytes
Age: 558039
Cache-Control: max-age=604800
Content-Type: text/html; charset=UTF-8
Date: Wed, 07 Jun 2023 12:34:56 GMT
Etag: "3147526947+gzip"
Expires: Wed, 14 Jun 2023 12:34:56 GMT
Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
Server: ECS (dcb/7F5B)
Vary: Accept-Encoding
X-Cache: HIT
Content-Length: 1256
<!doctype html>
<html>
<head>
<title>Example Domain</title>
<!-- More HTML content -->
</head>
<!-- More HTML content -->
</html>
Os headers fornecem informações valiosas sobre o servidor, o tipo de conteúdo, as políticas de cache e muito mais.
Acesso Avançado a Portas com Curl
Agora que você entende os conceitos básicos de como usar Curl com diferentes portas, vamos explorar técnicas mais avançadas para acesso e teste de portas.
Testando a Disponibilidade de Portas
Curl pode ser usado para verificar se uma porta específica está aberta em um servidor. Quando uma porta está aberta, Curl tentará estabelecer uma conexão e potencialmente receber dados. Quando uma porta está fechada, Curl relatará um erro.
Vamos testar algumas portas comuns:
## Teste se a porta 80 (HTTP) está aberta
curl -s -o /dev/null -w "%{http_code}\n" http://example.com:80
Este comando exibirá o código de status HTTP (normalmente 200 se a porta estiver aberta e o servidor estiver respondendo corretamente). A flag -s torna o Curl silencioso, -o /dev/null redireciona a saída para lugar nenhum e -w "%{http_code}\n" imprime apenas o código de status HTTP.
Vamos tentar mais algumas portas:
## Teste se a porta 443 (HTTPS) está aberta
curl -s -o /dev/null -w "%{http_code}\n" https://example.com:443
Isso deve retornar 200 ou outro código de status HTTP, indicando que a porta 443 está aberta.
Agora, vamos testar uma porta que provavelmente está fechada:
## Teste se a porta 81 (incomum) está aberta
curl -s --connect-timeout 5 http://example.com:81
Este comando provavelmente falhará com uma mensagem de erro como:
curl: (7) Failed to connect to example.com port 81: Connection refused
ou pode expirar após 5 segundos (conforme especificado por --connect-timeout):
curl: (28) Connection timed out after 5001 milliseconds
Acessando Servidores FTP
Curl suporta múltiplos protocolos, incluindo FTP. Vamos ver como acessar um servidor FTP:
curl ftp://ftp.gnu.org/gnu/
Este comando lista o conteúdo do diretório em ftp.gnu.org. A saída pode ser semelhante a:
drwxr-xr-x 8 1003 1003 4096 Dec 16 2020 0ad
drwxr-sr-x 5 1003 1003 4096 Nov 09 2020 8sync
drwxr-xr-x 2 1003 1003 4096 Jun 05 2015 GNUinfo
drwxr-xr-x 3 1003 1003 4096 Jan 23 2022 GNUnet
...
Criando um Scanner de Portas Simples
Vamos criar um script Bash simples para escanear uma faixa de portas em um servidor. Crie um novo arquivo chamado port_scanner.sh em seu diretório de projeto:
nano ~/project/port_scanner.sh
Adicione o seguinte conteúdo ao arquivo:
#!/bin/bash
## Simple port scanner using curl
## Usage: ./port_scanner.sh <hostname> <start_port> <end_port>
hostname=$1
start_port=$2
end_port=$3
echo "Scanning ports $start_port to $end_port on $hostname..."
echo
for port in $(seq $start_port $end_port); do
## Try to connect with a short timeout
curl -s --connect-timeout 1 "$hostname:$port" > /dev/null
## Check if the connection was successful
if [ $? -eq 0 ]; then
echo "Port $port is OPEN"
else
echo "Port $port is closed"
fi
done
echo
echo "Scan complete!"
Salve o arquivo pressionando Ctrl+X, depois Y e, em seguida, Enter.
Torne o script executável:
chmod +x ~/project/port_scanner.sh
Agora, execute o script para escanear as portas 80-85 em example.com:
~/project/port_scanner.sh example.com 80 85
A saída mostrará quais portas estão abertas e quais estão fechadas:
Scanning ports 80 to 85 on example.com...
Port 80 is OPEN
Port 81 is closed
Port 82 is closed
Port 83 is closed
Port 84 is closed
Port 85 is closed
Scan complete!
Este script simples demonstra como o Curl pode ser usado como uma ferramenta básica de varredura de portas. Em um cenário do mundo real, você gostaria de usar ferramentas especializadas como nmap para uma varredura de rede mais abrangente, mas este exemplo mostra a versatilidade do Curl.
Trabalhando com HTTPS e Conexões Seguras
Nesta etapa, exploraremos como usar Curl com HTTPS e lidar com várias opções relacionadas à segurança.
Entendendo as Conexões HTTPS
As conexões HTTPS usam os protocolos SSL/TLS para proteger a transmissão de dados. Quando você usa Curl para se conectar a um site HTTPS, ele verifica o certificado SSL do servidor por padrão.
Vamos tentar conectar a um site seguro:
curl https://www.google.com
Este comando conecta ao servidor HTTPS do Google e retorna o conteúdo HTML.
Lidando com a Verificação do Certificado SSL
Às vezes, você pode precisar se conectar a um servidor com um certificado autoassinado ou inválido. Nesses casos, você pode usar a opção -k ou --insecure para ignorar a validação do certificado:
curl -k https://www.google.com
Este comando se conectará ao site mesmo que o certificado não possa ser validado. A saída deve ser semelhante ao comando anterior.
Visualizando Informações do Certificado
Para examinar o certificado SSL de um site, use a opção -v (verbose):
curl -v https://www.google.com > /dev/null
Este comando exibirá informações detalhadas sobre o handshake SSL e o certificado, enquanto envia o conteúdo real para /dev/null. A saída inclui detalhes do certificado:
* Server certificate:
* subject: CN=www.google.com
* start date: ...
* expire date: ...
* subjectAltName: ...
* issuer: CN=GTS CA 1C3; O=Google Trust Services LLC; C=US
* SSL certificate verify ok.
Usando Versões Específicas de TLS
Você pode especificar qual versão do TLS usar com a opção --tlsv1.X:
## Forçar TLS 1.2
curl --tlsv1.2 https://www.google.com > /dev/null
Isso garante que o Curl use TLS 1.2 para a conexão.
Baixando Arquivos com Segurança
Curl pode baixar arquivos de fontes HTTPS. Vamos baixar um arquivo e salvá-lo com a opção -o:
curl -o ~/project/google_logo.png https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png
Este comando baixa o logotipo do Google e o salva como google_logo.png em seu diretório de projeto. Verifique se o arquivo existe:
ls -l ~/project/google_logo.png
Você deve ver uma saída como:
-rw-r--r-- 1 labex labex 5969 Jun 7 12:34 /home/labex/project/google_logo.png
Especificando Headers Personalizados para HTTPS
Ao trabalhar com APIs seguras, você geralmente precisa incluir headers de autenticação. Veja como fazer isso:
curl -H "Authorization: Bearer your_token_here" https://api.example.com
Substitua your_token_here por um token real, se você tiver um. Caso contrário, este comando provavelmente retornará um erro ou uma mensagem não autorizada do servidor.
Acessando HTTPS em Portas Não Padrão
Serviços HTTPS podem ser executados em portas diferentes de 443. Para acessar esses serviços, especifique a porta na URL:
curl https://example.com:8443
Este comando tenta se conectar a um serviço HTTPS na porta 8443. Como example.com não possui um serviço nesta porta, você provavelmente verá um erro:
curl: (7) Failed to connect to example.com port 8443: Connection refused
Isso demonstra que o Curl pode tentar se conectar a qualquer porta usando qualquer protocolo, tornando-o uma ferramenta versátil para testar serviços de rede.
Criando um Script Abrangente de Verificação de Portas
Nesta etapa final, criaremos um script mais sofisticado que usa Curl para verificar serviços comuns em um servidor de destino.
Entendendo as Portas de Serviço Comuns
Diferentes serviços normalmente são executados em portas padrão:
- Web (HTTP): Porta 80
- Web Segura (HTTPS): Porta 443
- FTP: Porta 21
- SSH: Porta 22
- SMTP (Email): Porta 25
- DNS: Porta 53
- Banco de Dados (MySQL): Porta 3306
- Banco de Dados (PostgreSQL): Porta 5432
Vamos criar um script que verifica essas portas comuns em um determinado host.
Criando o Script de Verificação de Serviço
Crie um novo arquivo chamado service_checker.sh em seu diretório de projeto:
nano ~/project/service_checker.sh
Adicione o seguinte conteúdo ao arquivo:
#!/bin/bash
## Service checker script using curl
## Usage: ./service_checker.sh <hostname>
hostname=$1
if [ -z "$hostname" ]; then
echo "Error: Please provide a hostname."
echo "Usage: ./service_checker.sh <hostname>"
exit 1
fi
echo "Checking common services on $hostname..."
echo
## Function to check a port with appropriate protocol
check_port() {
local port=$1
local service=$2
local protocol=$3
local timeout=2
echo -n "Checking $service (Port $port): "
## Use the appropriate protocol based on the service
if [ "$protocol" = "http" ]; then
curl -s --connect-timeout $timeout "http://$hostname:$port" > /dev/null
elif [ "$protocol" = "https" ]; then
curl -s --connect-timeout $timeout "https://$hostname:$port" > /dev/null
else
## For non-HTTP protocols, just try to connect to the port
curl -s --connect-timeout $timeout "$hostname:$port" > /dev/null
fi
## Check the result
if [ $? -eq 0 ]; then
echo "AVAILABLE"
else
echo "Not available"
fi
}
## Check common services
check_port 80 "Web Server (HTTP)" "http"
check_port 443 "Web Server (HTTPS)" "https"
check_port 21 "FTP Server" "tcp"
check_port 22 "SSH Server" "tcp"
check_port 25 "SMTP Server" "tcp"
check_port 53 "DNS Server" "tcp"
check_port 3306 "MySQL Database" "tcp"
check_port 5432 "PostgreSQL Database" "tcp"
check_port 8080 "Alternative Web Server" "http"
check_port 8443 "Alternative Secure Web Server" "https"
echo
echo "Service check complete!"
Salve o arquivo pressionando Ctrl+X, depois Y e, em seguida, Enter.
Torne o script executável:
chmod +x ~/project/service_checker.sh
Executando o Verificador de Serviço
Agora, execute o script para verificar os serviços em um site conhecido:
~/project/service_checker.sh example.com
Você verá uma saída semelhante a esta:
Checking common services on example.com...
Checking Web Server (HTTP) (Port 80): AVAILABLE
Checking Web Server (HTTPS) (Port 443): AVAILABLE
Checking FTP Server (Port 21): Not available
Checking SSH Server (Port 22): Not available
Checking SMTP Server (Port 25): Not available
Checking DNS Server (Port 53): Not available
Checking MySQL Database (Port 3306): Not available
Checking PostgreSQL Database (Port 5432): Not available
Checking Alternative Web Server (Port 8080): Not available
Checking Alternative Secure Web Server (Port 8443): Not available
Service check complete!
Esta saída mostra que example.com tem servidores web em execução nas portas 80 e 443, mas outros serviços comuns não estão publicamente acessíveis.
Entendendo os Resultados
Os resultados do nosso script fornecem informações valiosas:
Serviços disponíveis: Essas portas estão abertas e respondendo a solicitações, indicando que os serviços correspondentes estão em execução e acessíveis.
Serviços não disponíveis: Essas portas podem estar:
- Fechadas (nenhum serviço em execução)
- Filtradas por um firewall
- Em execução, mas configuradas para não responder a solicitações genéricas
Essas informações são úteis para:
- Administradores de rede verificando a disponibilidade do serviço
- Profissionais de segurança conduzindo reconhecimento inicial
- Desenvolvedores verificando se seus serviços estão configurados corretamente
Modificando o Script
Sinta-se à vontade para modificar o script para verificar portas ou serviços adicionais. Por exemplo, você pode adicionar verificações para:
- Redis (Porta 6379)
- MongoDB (Porta 27017)
- RDP (Porta 3389)
Para adicionar uma nova verificação de serviço, basta adicionar outra linha com a função check_port:
check_port 6379 "Redis Database" "tcp"
Isso demonstra a flexibilidade do Curl como uma ferramenta para teste e monitoramento de serviços de rede.
Resumo
Neste tutorial, você aprendeu como usar Curl para acessar diferentes portas em servidores e redes. Você:
- Aprendeu os conceitos básicos do Curl e como especificar portas em URLs
- Usou Curl para interagir com servidores web em portas padrão e não padrão
- Explorou diferentes métodos HTTP e headers
- Trabalhou com HTTPS e conexões seguras
- Criou scripts para verificar a disponibilidade de portas e o status do serviço
Essas habilidades são valiosas para a solução de problemas de rede, administração de sistemas e testes de segurança. A versatilidade do Curl o torna uma ferramenta essencial em seu kit de ferramentas de linha de comando.
Para prática adicional, tente:
- Usar Curl para interagir com APIs REST
- Testar diferentes timeouts de conexão e opções de repetição
- Explorar recursos mais avançados do Curl, como cookies, envios de formulários e configurações de proxy
- Aprimorar o script de verificação de serviço com protocolos adicionais e tratamento de erros
Lembre-se de que, embora o Curl seja poderoso para testes e varredura básica, ferramentas especializadas como Nmap fornecem recursos de varredura de rede mais abrangentes para uso profissional.
