Como Usar Curl para Acessar Diferentes Portas

LinuxBeginner
Pratique Agora

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:

  1. 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.

  2. 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.