¿Cómo Usar Curl para Acceder a Diferentes Puertos?

LinuxBeginner
Practicar Ahora

Introducción

Curl es una poderosa herramienta de línea de comandos que permite transferir datos utilizando varios protocolos, incluyendo HTTP, FTP y SFTP. En este tutorial, aprenderá a usar Curl para acceder a diferentes puertos en su servidor o red, lo que le permitirá solucionar problemas de conectividad y probar la disponibilidad de puertos.

Este laboratorio práctico le guiará a través de comandos básicos y avanzados de Curl para el acceso a puertos, ayudándole a comprender cómo operan los servicios de red en diferentes puertos. Al final de este laboratorio, podrá usar Curl con confianza para interactuar con servicios que se ejecutan en varios puertos.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 87%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Empezando con Curl

Curl, que significa "Client URL" (Cliente URL), es una herramienta de línea de comandos para transferir datos hacia o desde un servidor. Soporta numerosos protocolos, incluyendo HTTP, HTTPS, FTP, SFTP y muchos más. Antes de sumergirnos en operaciones específicas de puertos, asegurémonos de que comprende el uso básico de Curl.

Comando básico de Curl

Abra su terminal y escriba el siguiente comando para verificar si Curl está instalado en su sistema:

curl --version

Debería ver una salida similar a esta, mostrando la versión de Curl y las características soportadas:

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

Ahora, probemos una solicitud simple de Curl a un sitio web. Escriba el siguiente comando:

curl https://example.com

Este comando descarga el contenido HTML de example.com y lo muestra en su terminal. La salida será similar 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>

Entendiendo los puertos HTTP

Los servidores web típicamente se ejecutan en puertos específicos:

  • Puerto 80 para HTTP (no seguro)
  • Puerto 443 para HTTPS (seguro)

Cuando accede a un sitio web sin especificar un puerto, su navegador utiliza automáticamente estos puertos predeterminados. Sin embargo, con Curl, puede especificar explícitamente a qué puerto conectarse.

Intentemos acceder a un sitio web en el puerto HTTP estándar (puerto 80):

curl http://example.com:80

La salida debería ser similar a su comando Curl anterior, ya que el puerto 80 es el predeterminado para HTTP.

Ahora, intente acceder al mismo sitio web en el puerto HTTPS (puerto 443):

curl https://example.com:443

De nuevo, la salida debería ser similar, ya que el puerto 443 es el predeterminado para HTTPS.

En estos ejemplos, hemos especificado explícitamente los puertos en la URL utilizando el formato protocolo://dominio:puerto. Esta sintaxis es crucial cuando se trabaja con servicios en puertos no estándar.

Usando Curl con diferentes puertos

Ahora que comprende los conceptos básicos de Curl y la especificación de puertos, exploremos cómo interactuar con diferentes puertos.

Accediendo a puertos web no estándar

Los servidores web pueden ejecutarse en puertos distintos de 80 y 443. Para fines de prueba, configuremos un servidor web simple en el puerto 8000 utilizando el servidor HTTP incorporado de Python.

Primero, cree un archivo HTML simple para servir:

echo "<html><body><h1>Hello from port 8000!</h1></body></html>" > ~/project/test.html

Ahora, navegue al directorio que contiene el archivo e inicie un servidor HTTP simple en el puerto 8000:

cd ~/project
python3 -m http.server 8000 &

El & al final del comando ejecuta el servidor en segundo plano. Debería ver una salida como:

Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Ahora, use Curl para acceder a este servidor en el puerto 8000:

curl http://localhost:8000/test.html

Debería ver el contenido HTML que creamos:

<html>
  <body>
    <h1>Hello from port 8000!</h1>
  </body>
</html>

Cuando hayamos terminado con el servidor, podemos detenerlo encontrando su ID de proceso y matándolo:

ps aux | grep "python3 -m http.server"

Esto mostrará una salida similar 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 el ID de proceso (PID) en la segunda columna (1234 en este ejemplo) y mate el proceso:

kill $(pgrep -f "python3 -m http.server")

Usando diferentes métodos HTTP

Curl le permite especificar diferentes métodos HTTP utilizando la bandera -X. Intentemos una solicitud POST:

curl -X POST http://example.com

Esto envía una solicitud POST a example.com. La mayoría de los sitios web responderán con un mensaje que indica que esperan diferentes datos para las solicitudes POST.

Añadiendo encabezados a las solicitudes

Cuando se trabaja con APIs o servicios específicos, a menudo necesita enviar encabezados personalizados. Puede hacerlo con la bandera -H:

curl -H "Content-Type: application/json" http://example.com

Esto envía una solicitud con un encabezado de tipo de contenido JSON. La respuesta dependerá de cómo el servidor maneje este encabezado.

Visualizando los encabezados de respuesta

Para ver los encabezados de respuesta junto con el contenido, use la bandera -i:

curl -i http://example.com

Esto mostrará una salida similar 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>

Los encabezados proporcionan información valiosa sobre el servidor, el tipo de contenido, las políticas de almacenamiento en caché y más.

Acceso avanzado a puertos con Curl

Ahora que comprende los conceptos básicos del uso de Curl con diferentes puertos, exploremos técnicas más avanzadas para el acceso y las pruebas de puertos.

Prueba de disponibilidad de puertos

Curl se puede usar para verificar si un puerto específico está abierto en un servidor. Cuando un puerto está abierto, Curl intentará establecer una conexión y potencialmente recibir datos. Cuando un puerto está cerrado, Curl informará un error.

Probemos algunos puertos comunes:

## Test if port 80 (HTTP) is open
curl -s -o /dev/null -w "%{http_code}\n" http://example.com:80

Este comando mostrará el código de estado HTTP (típicamente 200 si el puerto está abierto y el servidor responde correctamente). La bandera -s hace que Curl sea silencioso, -o /dev/null redirige la salida a ninguna parte, y -w "%{http_code}\n" imprime solo el código de estado HTTP.

Probemos algunos puertos más:

## Test if port 443 (HTTPS) is open
curl -s -o /dev/null -w "%{http_code}\n" https://example.com:443

Esto debería devolver 200 u otro código de estado HTTP, indicando que el puerto 443 está abierto.

Ahora, probemos un puerto que probablemente esté cerrado:

## Test if port 81 (uncommon) is open
curl -s --connect-timeout 5 http://example.com:81

Este comando probablemente fallará con un mensaje de error como:

curl: (7) Failed to connect to example.com port 81: Connection refused

o podría agotar el tiempo de espera después de 5 segundos (como se especifica con --connect-timeout):

curl: (28) Connection timed out after 5001 milliseconds

Accediendo a servidores FTP

Curl soporta múltiples protocolos, incluyendo FTP. Veamos cómo acceder a un servidor FTP:

curl ftp://ftp.gnu.org/gnu/

Este comando lista el contenido del directorio en ftp.gnu.org. La salida podría verse así:

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

Creando un escáner de puertos simple

Creemos un script Bash simple para escanear un rango de puertos en un servidor. Cree un nuevo archivo llamado port_scanner.sh en su directorio del proyecto:

nano ~/project/port_scanner.sh

Agregue el siguiente contenido al archivo:

#!/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!"

Guarde el archivo presionando Ctrl+X, luego Y y luego Enter.

Haga que el script sea ejecutable:

chmod +x ~/project/port_scanner.sh

Ahora, ejecute el script para escanear los puertos 80-85 en example.com:

~/project/port_scanner.sh example.com 80 85

La salida mostrará qué puertos están abiertos y cuáles están cerrados:

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 simple demuestra cómo Curl se puede usar como una herramienta básica de escaneo de puertos. En un escenario del mundo real, querría usar herramientas especializadas como nmap para un escaneo de red más completo, pero este ejemplo muestra la versatilidad de Curl.

Trabajando con HTTPS y conexiones seguras

En este paso, exploraremos cómo usar Curl con HTTPS y manejar varias opciones relacionadas con la seguridad.

Entendiendo las conexiones HTTPS

Las conexiones HTTPS utilizan los protocolos SSL/TLS para asegurar la transmisión de datos. Cuando usa Curl para conectarse a un sitio HTTPS, verifica el certificado SSL del servidor de forma predeterminada.

Intentemos conectarnos a un sitio web seguro:

curl https://www.google.com

Este comando se conecta al servidor HTTPS de Google y devuelve el contenido HTML.

Manejo de la verificación del certificado SSL

A veces, es posible que necesite conectarse a un servidor con un certificado autofirmado o inválido. En tales casos, puede usar la opción -k o --insecure para omitir la validación del certificado:

curl -k https://www.google.com

Este comando se conectará al sitio incluso si el certificado no se puede validar. La salida debería ser similar al comando anterior.

Visualización de la información del certificado

Para examinar el certificado SSL de un sitio web, use la opción -v (verbose):

curl -v https://www.google.com > /dev/null

Este comando mostrará información detallada sobre el handshake SSL y el certificado mientras envía el contenido real a /dev/null. La salida incluye detalles del 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 versiones específicas de TLS

Puede especificar qué versión de TLS usar con la opción --tlsv1.X:

## Force TLS 1.2
curl --tlsv1.2 https://www.google.com > /dev/null

Esto asegura que Curl use TLS 1.2 para la conexión.

Descargando archivos de forma segura

Curl puede descargar archivos de fuentes HTTPS. Descarguemos un archivo y guardémoslo con la opción -o:

curl -o ~/project/google_logo.png https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png

Este comando descarga el logotipo de Google y lo guarda como google_logo.png en su directorio del proyecto. Verifique si el archivo existe:

ls -l ~/project/google_logo.png

Debería ver una salida como:

-rw-r--r-- 1 labex labex 5969 Jun 7 12:34 /home/labex/project/google_logo.png

Especificando encabezados personalizados para HTTPS

Cuando se trabaja con APIs seguras, a menudo necesita incluir encabezados de autenticación. Así es como hacerlo:

curl -H "Authorization: Bearer your_token_here" https://api.example.com

Reemplace your_token_here con un token real si tiene uno. De lo contrario, este comando probablemente devolverá un error o un mensaje no autorizado del servidor.

Accediendo a HTTPS en puertos no estándar

Los servicios HTTPS pueden ejecutarse en puertos distintos de 443. Para acceder a dichos servicios, especifique el puerto en la URL:

curl https://example.com:8443

Este comando intenta conectarse a un servicio HTTPS en el puerto 8443. Dado que example.com no tiene un servicio en este puerto, probablemente verá un error:

curl: (7) Failed to connect to example.com port 8443: Connection refused

Esto demuestra que Curl puede intentar conectarse a cualquier puerto usando cualquier protocolo, lo que lo convierte en una herramienta versátil para probar servicios de red.

Creando un script de verificación de puertos completo

En este paso final, crearemos un script más sofisticado que usa Curl para verificar servicios comunes en un servidor objetivo.

Entendiendo los puertos de servicio comunes

Diferentes servicios típicamente se ejecutan en puertos estándar:

  • Web (HTTP): Puerto 80
  • Web segura (HTTPS): Puerto 443
  • FTP: Puerto 21
  • SSH: Puerto 22
  • SMTP (Correo electrónico): Puerto 25
  • DNS: Puerto 53
  • Base de datos (MySQL): Puerto 3306
  • Base de datos (PostgreSQL): Puerto 5432

Creemos un script que verifique estos puertos comunes en un host dado.

Creando el script de verificación de servicios

Cree un nuevo archivo llamado service_checker.sh en su directorio del proyecto:

nano ~/project/service_checker.sh

Agregue el siguiente contenido al archivo:

#!/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!"

Guarde el archivo presionando Ctrl+X, luego Y y luego Enter.

Haga que el script sea ejecutable:

chmod +x ~/project/service_checker.sh

Ejecutando el verificador de servicios

Ahora, ejecute el script para verificar los servicios en un sitio web conocido:

~/project/service_checker.sh example.com

Verá una salida similar 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 salida muestra que example.com tiene servidores web ejecutándose en los puertos 80 y 443, pero otros servicios comunes no son públicamente accesibles.

Entendiendo los resultados

Los resultados de nuestro script proporcionan información valiosa:

  1. Servicios disponibles: Estos puertos están abiertos y responden a las solicitudes, lo que indica que los servicios correspondientes se están ejecutando y son accesibles.

  2. Servicios no disponibles: Estos puertos podrían estar:

    • Cerrados (sin servicio en ejecución)
    • Filtrados por un firewall
    • En ejecución pero configurados para no responder a solicitudes genéricas

Esta información es útil para:

  • Administradores de red que verifican la disponibilidad del servicio
  • Profesionales de seguridad que realizan reconocimiento inicial
  • Desarrolladores que verifican que sus servicios estén configurados correctamente

Modificando el script

Siéntase libre de modificar el script para verificar puertos o servicios adicionales. Por ejemplo, podría agregar verificaciones para:

  • Redis (Puerto 6379)
  • MongoDB (Puerto 27017)
  • RDP (Puerto 3389)

Para agregar una nueva verificación de servicio, simplemente agregue otra línea con la función check_port:

check_port 6379 "Redis Database" "tcp"

Esto demuestra la flexibilidad de Curl como una herramienta para la prueba y el monitoreo de servicios de red.

Resumen

En este tutorial, ha aprendido a usar Curl para acceder a diferentes puertos en servidores y redes. Ha:

  • Aprendido los conceptos básicos de Curl y cómo especificar puertos en las URLs
  • Usado Curl para interactuar con servidores web en puertos estándar y no estándar
  • Explorado diferentes métodos HTTP y encabezados (headers)
  • Trabajado con HTTPS y conexiones seguras
  • Creado scripts para verificar la disponibilidad de puertos y el estado de los servicios

Estas habilidades son valiosas para la solución de problemas de red, la administración de sistemas y las pruebas de seguridad. La versatilidad de Curl lo convierte en una herramienta esencial en su conjunto de herramientas de línea de comandos.

Para práctica adicional, intente:

  • Usar Curl para interactuar con APIs REST
  • Probar diferentes tiempos de espera de conexión y opciones de reintento
  • Explorar funciones más avanzadas de Curl como cookies, envíos de formularios y configuraciones de proxy
  • Mejorar el script de verificación de servicios con protocolos adicionales y manejo de errores

Recuerde que, si bien Curl es poderoso para pruebas y escaneo básico, herramientas especializadas como Nmap proporcionan capacidades de escaneo de red más completas para uso profesional.