curl para todo

Y para todos

#herramientas#linux#seguridad
Adrian Cápitas Publicado el

Si trabajas con sistemas, usas curl. Aunque no lo sepas: además de la herramienta de línea de comandos, está libcurl, la biblioteca que llevan dentro coches, televisores, routers, impresoras, consolas y una cantidad absurda de programas. El propio proyecto habla de más de veinte mil millones de instalaciones, y su autor, Daniel Stenberg, contaba a finales de 2022 que curl funcionaba en 89 sistemas operativos.

El nombre es un juego de palabras: client for URLs, que en inglés también se lee see URL («ver URL»). Y eso es lo que hace: hablar con cualquier cosa que tenga una URL. Nació en 1998 (venía de herramientas anteriores, httpget y urlget) y hoy entiende HTTP en todas sus versiones, FTP, SFTP, SMTP, IMAP, MQTT, LDAP y unos cuantos protocolos más.

Casi todo el mundo lo usa para descargar un fichero y poco más. En este artículo te cuento cómo lo uso yo a diario, de lo básico a lo que menos gente conoce.

Lo básico, bien hecho

Para descargar algo en un script, esta es la combinación que uso siempre:

curl -fsSL -o instalar.sh https://example.com/instalar.sh

Y ya que estamos: no hagas curl ... | sh con algo que no has leído. Descárgalo, léelo y ejecútalo después. Ahorra sustos.

Ver qué está pasando de verdad

Cuando algo falla con HTTP, lo primero es mirar la conversación entera:

curl -v https://example.com/

Con -v ves la resolución DNS, la conexión, la negociación TLS, las cabeceras que envías y las que recibes. Si necesitas todavía más detalle, --trace-ascii traza.txt vuelca todo lo que entra y sale.

Para ver solo las cabeceras de respuesta de una petición GET normal (con -I se hace una petición HEAD, que algunos servidores tratan distinto):

curl -sS -D - -o /dev/null https://example.com/

Es mi forma rápida de comprobar cabeceras de seguridad, como la política de seguridad de contenidos o HSTS:

curl -sS -D - -o /dev/null https://example.com/ | grep -i -E 'strict-transport|content-security'

¿Dónde se va el tiempo?

-w (--write-out) imprime variables al terminar la petición. Mi favorita es el desglose de tiempos:

curl -sS -o /dev/null -w '
       DNS: %{time_namelookup}s
  conexión: %{time_connect}s
       TLS: %{time_appconnect}s
 1.er byte: %{time_starttransfer}s
     total: %{time_total}s
    código: %{http_code}
' https://example.com/

Los tiempos son acumulados desde el inicio. Si el DNS ya se lleva medio segundo, el problema no está en tu aplicación; si la diferencia grande está entre TLS y el primer byte, es el servidor el que tarda en responder.

Probar un servidor antes de cambiar el DNS

Esta es la que más tiempo me ha ahorrado en migraciones. Has montado el servidor nuevo, pero el DNS sigue apuntando al viejo. ¿Cómo lo pruebas con su nombre real y su certificado real, sin tocar el /etc/hosts?

curl --resolve example.com:443:203.0.113.10 https://example.com/

--resolve le dice a curl que, para example.com en el puerto 443, use esa IP. Todo lo demás (la cabecera Host, el SNI de TLS, la validación del certificado) va como si el DNS ya estuviera cambiado. Si quieres apuntar a otro nombre en lugar de a una IP, tienes --connect-to:

curl --connect-to example.com:443:servidor-nuevo.example.net:443 https://example.com/

Certificados

Para ver rápidamente quién emitió un certificado y cuándo caduca:

curl -sSv -o /dev/null https://example.com/ 2>&1 | grep -E 'subject:|issuer:|expire date:'

Si el certificado no es válido, curl se niega a seguir, y hace bien. La opción -k (--insecure) se salta esa comprobación: úsala solo para diagnosticar y nunca en un script. Si el problema es que el servidor usa una CA propia, dile a curl cuál es con --cacert ca.crt (en OpenSSL básico y EasyRSA tienes cómo crearlas).

Hablar con APIs

Desde la versión 7.82, --json hace en una sola opción lo que antes eran tres: envía el cuerpo por POST y pone las cabeceras Content-Type y Accept a application/json:

curl --fail-with-body --json '{"nombre": "Ana", "rol": "admin"}' https://api.example.com/usuarios

--fail-with-body es como -f, pero te muestra el cuerpo de la respuesta de error, que en una API suele traer el motivo. Con --json @fichero.json lee el cuerpo de un fichero, y con --json @- de la entrada estándar.

Para los parámetros de la URL, --url-query se encarga de codificarlos por ti:

curl --url-query "q=podman compose" --url-query "pagina=2" https://api.example.com/buscar

Y, combinado con jq, tienes un cliente de API en una línea:

curl -fsS https://api.example.com/usuarios | jq -r '.[] | select(.rol == "admin") | .nombre'

Los secretos, fuera de la línea de comandos

Cuidado con esto: todo lo que pones en la línea de comandos lo puede ver cualquier usuario de la máquina con ps, y además acaba en el historial de la terminal. Así que nada de -H "Authorization: Bearer eyJ..." a pelo. Dos alternativas:

# 1. Cabeceras desde un fichero (con permisos 600)
curl -H @cabeceras.txt https://api.example.com/

# 2. Variables (desde curl 8.3): %TOKEN importa la variable de entorno TOKEN
curl --variable %TOKEN --expand-header "Authorization: Bearer {{TOKEN}}" https://api.example.com/

Para usuario y contraseña, lo mismo: mejor un fichero .netrc con --netrc-file que -u usuario:contraseña.

Vigilar un servicio

curl es, también, el sistema de monitorización más sencillo que existe. Esto comprueba que una web responde en menos de 10 segundos, reintenta dos veces ante cualquier fallo y termina con error si no lo consigue:

curl -fsS --max-time 10 --retry 2 --retry-all-errors -o /dev/null https://miapp.example.com/salud \
  || echo "miapp no responde" | systemd-cat -p err -t vigilancia

Mételo en un temporizador de systemd y ya tienes una vigilancia básica (aunque, como cuento en Arquitectura de contenedores simple, lo ideal es vigilar también desde fuera de la máquina).

Y ahora, lo que casi nadie sabe que hace

Descargas en paralelo y con patrones. Los corchetes generan secuencias y -Z descarga en paralelo:

curl -Z -O "https://example.com/imagenes/foto[01-20].webp"

Enviar correo. curl habla SMTP, así que un script puede mandar un aviso sin instalar nada más:

curl --ssl-reqd smtps://smtp.example.com:465 \
  --netrc-file ~/.netrc-smtp \
  --mail-from avisos@example.com \
  --mail-rcpt yo@example.com \
  -T mensaje.txt

Donde mensaje.txt es el correo tal cual, con sus cabeceras:

From: Avisos <avisos@example.com>
To: <yo@example.com>
Subject: La copia de seguridad ha fallado

Revisa el servidor, que la copia de esta noche no ha terminado.

Subir ficheros por FTP o SFTP con -T, leer ficheros locales con file://, o consultar un diccionario con el protocolo DICT:

curl dict://dict.org/d:curl

Para saber qué protocolos y funciones trae tu curl (depende de cómo se compiló), mira la salida de curl -V.

Conclusión

curl está instalado en prácticamente todas las máquinas que vas a tocar, y eso lo convierte en la herramienta de diagnóstico más universal que tienes. Merece la pena dedicarle una tarde a curl --help all o al manual (man curl): cada vez que lo hago descubro una opción que me ahorra un script entero.

Compartir

También te puede interesar