tutorial_de_curl

curl significa “Cliente para URL”. Se trata de un programa capaz de realizar transferencias de Internet, donde actúa como cliente, cargando y descargando datos desde un servidor remoto. Los datos pueden responder a cualquier tipología: texto, imágenes, audio, video, etcétera.

Curl soporta tanto protocolos no autenticados (como HTTP o FTP), como sus contrapartes autenticados más modernos (como HTTPS o SFTP).

Historia

curl comenzó originalmente en 1996 como un proyecto llamado httpget, de Rafael Sagula, quien luego transfirió el control del mismo a Daniel Stenberg. Daniel lo renombró a curl en 1998, y en 2000 dividió la funcionalidad de red de datos para colocarla en la biblioteca libcurl. Por lo cual curl en sí se trasnformó en un envolvedor para la línea de comandos alrededor de dicha biblioteca.

Curl se encuentra liberado bajo una licencia MIT ligeramente modificada. Opera en 92 sistemas operativos en cuenta con más de 20 mil millones de instalaciones en todo el mundo.

Desde la línea de comandos operarás el comando curl , haciendo caso a las reglas de sintaxis del mismo.

Sintaxis básica de Curl

Para curl, todo lo que comience con - o lo interpretará como una opción de curl.

Existen opciones de curl que usan sintaxis cortas (con un guión -):

curl -V

…y opciones de curl de sintaxis largas (usan doble guión ):

curl --version
Todas las opciones de curl están disponibles en el formato “largo”, pero las más usadas son las que usan la versión “corta”. El programa cuenta actualmente con unas 250 opciones, pero en este tutorial dejaremos de lado aquellas que se usan en otros protocolos distintos a http/https.

Sintaxis complejas

Las órdenes más complejas recurren a este tipo de sintaxis.

Opciones Boleanas

Algunas opciones son del tipo booleano. Podremos activarlas con:

curl --silent http://httpbin/uuid

…o desactivarlas con:

curl --no-silent http://httpbin/uuid
Opciones Argumentadas

Algunas opciones de curl aceptan argumentos, que permiten especificarle más definidamente qué es lo que queremos que haga:

curl --output /tmp/uuid.json http://httpbin/uuid

Aquellos argumentos que contienen espacios en blanco deben entrecomillarse: "...". Por ejemplo:

curl -o /dev/null --write-out "type: %{content_type}" http://httpbin/uuid

Transmisiones No autenticadas

Curl puede desactivar la verificación de servidor con la opción –insecure, pero es mejor no hacer esto por seguridad.

Los datos transferidos sobre un protocolo no autenticado pueden ser intereceptados y utilizados, de manera que siempre es mejor usar los autenticados.

Todo aquello que pasemos a curl que no comience con - o , será considerado una URL.

Curl soporta URLs según la forma de URIs aceptada en la protocolización RFC 3986, o sea: esquema://usuaria:contraseña@huésped:puerto/ruta?solicitud#fragmento. En esta:

  • esquema define un protocolo (como HTTP o FTP). De omitírse, curl intentará adivinarlo. La usuaria y la contraseña son credenciales de autenticación (transmitir las credenciales en la URL generalmente no está recomendado o permitido por motivos de seguridad).
  • huesped es el nombre de máquina, nombre de dominio o dirección IP del servidor.
  • puerto0 es el número de puerto de transmisión. De omitirse, curl empleará el puerto por defecto asociado con el esquema (por ejemplo, 80 para http o 443 para https).
  • ruta es la ruta al recurso en el servidor.
  • solicitud es usualmente una secuencia de pares nombre=valor separada por un caracter &.

Solicitud

Si fuese necesario pasar a curl una gran cantidad de parámetros de URL, la parte que involucra a la solicitud podría resultar extensamente larga. La opción –url-query permite especificar separadamente estas partes, para que pasarle URL largas nos resulte más cómodo:

curl http://httpbin/get --url-query "name=Fulana" --url-query "edad=25"

URL Múltiples

Curl acepta cualquier cantidad de URLs, pero cada una de las cuales requerirá definirle un destino (ya sea un fichero o stdout). Por ejemplo, este comando guardará la primer UUID en /tmp/uuid1.json y la segunda UUID en /tmp/uuid2.json:

curl
  -o /tmp/uuid1.json http://httpbin/uuid
  -o /tmp/uuid2.json http://httpbin/uuid
 
&& cat /tmp/uuid1.json
&& cat /tmp/uuid2.json
De aquí en mas, ocasionalmente en este tutorial se mostrarán multilíneas a modo ilustrativo. En realidad curl espera una línea de comando única, o a lo sumo líneas divididas con \).

La opción -O deriva el nombre de fichero desde la URL:

curl --output-dir /tmp
  -O http://httpbin/cualquier/ruta/uno
  -O http://httpbin/cualquier/ruta/dos
 
&& ls /tmp

Para guardar ambas respuestas en un mismo fichero, podremos usar metacaracteres de redirección:

curl http://httpbin/uuid http://httpbin/uuid > /tmp/uuid.json
 
&& cat /tmp/uuid.json

Englobado de URL

Curl expande automáticamente aquellas expresiones englobadas en URLs, en múltiples URLs específicas.

Por ejemplo, este comando solicita tres rutas distintas (al, bt, gm), cada una con dos parámetros distintos (num=1 y num=2), totalizando seis URLs:

curl --output-dir /tmp -o "salida_#1_#2.txt"
  http://httpbin/cualquier/ruta/{al,bt,gm}?num=[1-2]
 
&& ls /tmp

Si en las URLs indicadas existiesen los caracteres interpretables de englobado ([]{}), esto provocaría un tremendo dolor de cabeza. Sin embargo, podremos desactivar su interpretado de englobado gracias a la opción –globoff. De este modo, Curl tratará las URLs de manera literal, sin importar que contengan dichos caracteres.

Es posible usar la opción –parallel (-Z) para ordenar a Curl el procesado de URLs de forma concurrente.

En la medida que se incrementa el número de opciones, el comando Curl se volverá más difícil de descifrar. Para hacerlo más legible, podríamos preparar un fichero de configuración delimitando una opción por línea (el uso de es opcional):

Config file
output-dir /tmp
show-error
silent

Por defecto, Curl lee el fichero de configuración desde $HOME/.curlrc, pero esto puede alterarse indicándolo con la opción –config (-K):

curl --config /sandbox/.curlrc http://httpbin/uuid

Debemos estar atentos que al configurar las opciones de curl, tal configuración se aplicará a todas las URLs que procese curl. Por ejemplo, aquí ambos encabezados se envían a ambas URLs:

curl
  -H "x-num: uno" http://httpbin/headers?1
  -H "x-num: dos" http://httpbin/headers?2

En ocasiones no deseamos hacer esto. Para resetear el estado entre las llamadas a las URLS, debemos recurrir a la opción –next:

curl
  -H "x-num: uno" http://httpbin/encabezados?1
  --next
  -H "x-num: dos" http://httpbin/encabezados?2

Curl cuenta con dos medidores de progreso distintos para saber cómo va la transferencia ordenada.

Indicador de progreso verboso
curl --no-silent http://httpbin/uuid
Indicador de progreso compacto

El otro es indicador compactito:

curl --no-silent --progress-bar http://httpbin/uuid
Desactivar indicación de progreso

La opción –silent desactiva completamente el medidor:

curl --silent http://httpbin/uuid

Ahora que entendemos cómo funciona Curl y la sintaxis de sus opciones, podremos ver sus opciones específicas.

Versionado

–version (-V) explica todo sobre la versión instalada de curl. Por ejemplo:

curl -V

…listará linea a línea las versiones de Curl en sí y sus dependencias, la fecha de lanzamiento, los protocolos disponibles, y las características activadas.

–verbose (-v) hace que Curl sea verboso, lo que puede ser útil en depuración:

curl -v http://httpbin/uuid

Si –verbose es insuficiente, podríamos intentar con el inefable –trace (el - envía la salida de trace a stdout):

curl --trace - http://httpbin/uuid

…o bien con –trace-ascii:

</code bash> curl –trace-ascii - http://httpbin/uuid </code>

Utiliza –write-out (-w) para extraer información específica sobre la respuestas recibidas. Este soporta más de 50 variables. Por ejemplo, aquí extraemos el código de status y la respuesta del Content-type:

curl
  -w "\nstatus: %{response_code}\ntype: %{content_type}"
  http://httpbin/status/429

…o algunos encabezados de la respuesta:

curl
  -w "\ndate: %header{date}\nlength: %header{content-length}"
  http://httpbin/status/429

La opción –remote-name (-O) le dice a curl que guarde la salida en un fichero indicado en base a la URL, (específicamente, por la parte que sigue a la última / de ésta). A menudo se usa en conjunto con la opción –output-dir, lo que le dirá a Curl exactamente donde colocar el fichero a guardar:

curl --output-dir /tmp -O http://httpbin/uuid
 
&& cat /tmp/uuid

Si tal directorio es inexistente, –output-dir no lo creará por tí. Deberás usar –create-dirs para que esto suceda:

curl --output-dir /tmp/alguna/ruta --create-dirs
  -O http://httpbin/uuid
 
&& cat /tmp/alguna/ruta/uuid

Puedes usar –max-filesize (en bytes) para limitar el tamaño máximo de respuesta permitido (aunque esto a menudo no se conoce por adelantado, lo que podría provocar fallas).

Reintentado

A veces puede suceder que el huésped remoto esté indispuesto. Para hacer caso a estas situaciones, Curl provee la opción –retry [numero]. Si la solicitud falla, Curl lo intentará nuevamente, pero no más allá de la cantidad de veces indicada por numero:

curl -i --retry 3 http://httpbin/unstable

(esta URL falla el 50% de las veces)

Podrás indicar la cantidad máxima de tiempo que Curl invertirá en intentar nuevamente la solicitud, por medio de la opción –retry-max-time (segundos), o bien el retraso entre reintentos, con –retry-delay (también en segundos):

curl -i --retry 3 http://httpbin/unstable
  --retry-max-time 2
  --retry-delay 1

Para Curl, “request failed” implica recibir alguno de los códigos de respuesta HTTP: 408, 429, 500, 502, 503 o 504. Si la solicitud falla con un error de “connection refused”, Curl no intentará nuevamente. Sin embargo, este funcionamiento típico puede alterarse con la opción –retry-connrefused, o incluso activar los reintentos para todo tipo de problemas con la opción –retry-all-errors.

Curl a menudo se usa para bajar información (descargar) del servidor, pero también puede subirla. Para ello use la opción –upload-file (-T):

echo "hola Tercer Mundo!" > /tmp/hola.txt &&
 
curl -T /tmp/hola.txt http://httpbin/put

Para las cargas de datos a través de protocolo HTTP, Curl usa el método PUT.

Controles de Transferencia

Para detener las descargas lentas, debe configurar la velocidad de descarga mínima permitida (en bytes por segundo) con –speed-limit. Por defecto, Curl revisa la velocidad en intervalos de 30 segundos, pero este comportamiento típico puede ser modificado con la opción –speed-time.

Por ejemplo, para permitir no menos de 10 bytes/segundo durante un intervalo de 3 segundos:

curl -v --speed-limit 10 --speed-time 3 http://httpbin/get

Para limitar el uso de ancho de banda, utiliza la opción –limit-rate. Esta acepta cualquier cantidad, desde bytes a petabytes:

curl --limit-rate 3 http://httpbin/get
curl --limit-rate 3k http://httpbin/get
curl --limit-rate 3m http://httpbin/get
curl --limit-rate 3g http://httpbin/get
curl --limit-rate 3t http://httpbin/get
curl --limit-rate 3p http://httpbin/get

Otra cosa para limitar es el número de solicitudes concurrentes (ej, si descargas muchos ficheros). Usa –rate para tal cosa. Acepta segundos, minutos, horas o días:

curl --rate 3/s http://httpbin/anything/[1-9].txt
curl --rate 3/m http://httpbin/anything/[1-9].txt
curl --rate 3/h http://httpbin/anything/[1-9].txt
curl --rate 3/d http://httpbin/anything/[1-9].txt

Resolución de nombre

Por defecto, curl usa tu servidor DNS para resolver desde nombres de huésped a direcciones IP. Pero puedes forzarlo a resolver una IP específica por medio de la opción –resolve:

curl --resolve texto-plano.xyz:80:127.0.0.1
  http://httpbingo.org:8080/get

</code>

…(este falla porque nadie escucha en 127.0.0.1)

O puedes incluso mapear un par maquina:puerto a otro par maquina:puerto con –connect-to:

curl --connect-to texto-plano.xyz:443:texto-plano:80
  http://texto-plano.xyz:443/

(este funcionará bien)

También existen configuraciones a nivel conexión.

timeouts

Para limitar la cantidad de tiempo que curl se pasa interactuando con una única URL, usa –max-time (en fraccionales de segundo):

curl --max-time 0.5 http:/httpbin/delay/1

(este falla)

En lugar de limitar el tiempo total, puedes usar –connect-timeout para limitar sólo el tiempo que toma establecer la conexión en la red:

curl --connect-timeout 0.5 http:/httpbin/delay/1

(este funciona bien)

Credenciales

Casi nunca querrás pasar nombre de usuario y contraseña en el comando de curl en sí. Una forma de evitarlo es usar el fichero $HOME/netrc. Especifica los nombres de máquina y credenciales para accederlos:

machine httpbin
login pedro
password chori

machine ejemplo.com
login pablo
password pan

Pasa la opción –netrc para usar el fichero $HOME/.netrc, o –netrc-file para usar uno específico:

echo -e "machine httpbin\nlogin pedro\npassword chori" > /tmp/netrc &&
 
curl --netrc-file /tmp/netrc
  http://httpbin/basic-auth/pedro/chori

Cuando curl finaliza (“sale”), devuelve un valor numérico a la shell denominado status de salida. El éxito se señala con 0, y los errores tienen 100 valores distintos.

Por ejemplo, aquí hay un exit status 7 (“failed to connect to host”):

curl http://httpbin:1313/get

Puede acceder al status de salida a través de la variable de intérprete $?.

HTTP

Principalmente, Curl se usa para trabajar con HTTP, de modo que hablemos un poco de esto.

HTTP/1.x es un protocolo de texto plano que describe la comunicación entre el cliente y el servidor. El cliente envía mensajes como este:

POST /fulana/sitio HTTP/1.1
host: texto-plano.xyz
content-type: application/json
user-agent: curl/7.87.0
 
{
    "message": "Hola Tercer Mundo!"
}
  • La primer línea es una línea de solicitud. El método (POST) define la operación que el cliente desea realizar. La ruta (/fulana/sitio) es la URL del recurso solicitado (sin poner protocolo, dominio ni puerto). La versión (HTTP/1.1) indica la versión del protocolo HTTP usado.
  • Las líneas siguientes (hasta la línea en blanco) son encabezados. Cada envabzado tiene un par clave-valor que le dice al servidor información útil sobre la solicitud. En este caso es el nombre de host del servidor (texto-plano.xyz), el tipo de contenido (application/json) y la auto-identificación del cliente (user-agent).
  • Finalmente, estos son los datos que el cliente envía al servidor.

En respuesta a esto, el cliente recibirá un mensaje como este:

HTTP/1.1 200 OK
date: Mon, 28 Aug 2023 07:51:49 GMT
content-type: application/json
 
{
    "message": "Como va!"
}
  • La primer línea es la línea de status. La versión (HTTP/1.1) indica la versión del protocolo HTTP. El código de status (200) informa si la solicitud fue exitosa o no, y porqué (existen muchos códigos de status para distintas situaciones). El mensaje de status es una descripción para el humano del código de status (HTTP/2 no la tiene).
  • Las siguientes líneas (hasta la línea en blanco) son encabezados. Al igual que los encabezados de solicitud, estos dan información útil sobre la respuesta del cliente.
  • Finalmente, va la información real que el servidor envía al cliente.

El protocolo HTTP carece de estado, por lo cual cualquier estado deberá estar contenido dentro de la solicitud en sí (ya sea en el encabezado o en el cuerpo).

HTTP/2

HTTP/2, es el sucesor de HTTP/1.1, y en realidad es un protocolo binario. Sin embargo, curl presenta los mensajes de HTTP/2 en texto plano (al igual que en HTTP/1.1), así que para propósitos de uso de curl, podemos ignorar este hecho.

Método HTTP

Curl soporta todos los métodos HTTP (a menudos referidos como verbos).

GET (el que es por defecto, no necesita opciones):

curl http://httpbin/get

HEAD (-I/–head, sólo devuelve los encabezados):

curl -I http://httpbin/head

POST (-d/–data para datos o -F/–form para el formulario HTTP):

curl -d "name=fulana" http://httpbin/post

O cualquier otro método con –request (-X):

curl -X PATCH -d "name=fulana" http://httpbin/patch

Código de Respuesta

Típicamente, los códigos de status 2xx (200, específicamente) son considerados “éxitosos”, mientras que los 4xx son tratados como errores del lado del cliente, y los 5xx como errores del lado del servidor. Pero a curl no les importan los códigos, para él, cualquier respuesta HTTP obtenida es considerada un éxito:

curl http://httpbin/status/503 && echo OK

Para hacer que curl trate los códigos 4xx y 5xx como errores, use –fail (-f):

curl -f http://httpbin/status/503 && echo OK

Para presentar el código de respuesta, use –write-out con la variable response_code:

curl -w "%{response_code}" http://httpbin/status/200
Encabezados de Respuesta

Para presentar los encabezados de respuesta, use –head (-i):

curl -i http://httpbin/status/200

O guárdelos en un fichero usando –dump-header (-D):

curl -D /tmp/encabezados http://httpbin/status/200
 
&& cat /tmp/encabezados
Cuerpo de Respuesta

Lo que devuelve por defecto curl es el cuerpo de respuesta, a menudo llamado payload o cabeza de guerra.

curl http://httpbin/get

Puede solicitar al servidor comprimir los datos por medio de –compressed, pero aún así curl los presentará descomprimidos:

curl --compressed http://httpbin/get

(note como el encabezado de solicitud Accept-Encoding ha cambiado)

Rangos

Para solicitar al servidor una sección de los datos en lugar del todo el entero, se usa la opción –range (r). Esto provocará que curl solicite el rango de bytes especificados.

Por ejemplo, para solicitar 50 bytes de datos a partir del 100° byte:

curl --range 100-150 http://httpbin/range/1024

Tenga presente que el server puede ignorar un pedido delimitado, y devolver la respuesta entera y completa (dependiendo de su propia configuración de seguridad).

Si está descargando datos de un servidor, también puede usar –continue-at (-C) para continuar la transmisión previa en un offset determinado:

curl --continue-at 1000 http://httpbin/range/1024

Versiones HTTP

Por defecto, curl usa HTTP/1.1 para el esquema de transmisión http, y HTTP/2 para https. Se puede cambiar esto con modificadores:

curl --http0.9
curl --http1.0
curl --http1.1
curl --http2
curl --http3

Para saber qué versión de HTTP soporta el server, use la variable de respuesta http_version:

curl -w "%{http_version}" http://httpbin/status/200

Las solicitudes condicionales son útiles cuando queremos evitar descargar datos ya descargados (asumiendo que la transmisión no está detenida). Curl soporta dos condiciones distintas: etiquetado de hora de fichero (“file timestamp”) y etiquetado electrónico (“etag”).

Para condiciones de Timestamp use –time-cond (-z).

Descargar datos sólo si el recurso remoto es más nuevo (la condición se retiene):

curl --time-cond "Aug 30, 2023" http://httpbin/etag/etag

…o mas viejo (la condición falla):

curl -i --time-cond "-Aug 30, 2023" http://httpbin/etag/etag

Las condiciones Etag son un poco mas completas. Un etag es un valor devuelto por el servidor que identifica unívocamente la versión actual del recurso solicitado. A menudo es un hash de los datos.

Para revisar un etag, curl debe primero guardarlo con –etag-save:

curl --etag-save /tmp/etags http://httpbin/etag/etag

…y usar –etag-compare en las solicitudes subsecuentes:

curl --etag-save /tmp/etags -o /dev/null http://httpbin/etag/etag &&
 
curl -i --etag-compare /tmp/etags http://httpbin/etag/etag
Las condiciones Timestamp confían en el encabezado de respuesta Last-Modified (“modificado por última vez”), de modo que si el servidor no lo ofrece, el recurso siempre será considerado el más actual. Lo mismo sucede para las condiciones etag y para el encabezado de respuesta Etag.

Envío HTTP

POST envía datos al servidor. Por defecto, es un conjunto de pares clave-valor condificados en una sola cadena con un encabezado Content-Type application/x-www-form-urlencoded.

Puede usar –data (-d) para especificar los pares clave-valor individualmente (o para la cadena entera):

curl -d name=fulana -d edad=25 http://httpbin/post

Para enviar datos desde un fichero, usamos @ con la ruta del fichero. Usamos –header (-H) para cambiar el encabezado Content-Type de acuerdo a los contenidos del fichero:

echo "Fulana, edad 25" > /tmp/data.txt &&
 
curl -d @/tmp/datos.txt -H "content-type: text/plain"
  http://httpbin/post

–data-raw envía datos de manera similar a –data, pero sin interpretar el caracter @.

Para enviar datos JSON, usamos –json. Automáticamente cambiará los encabezados Content-Type y Accept de manera acorde:

curl --json '{"nombre": "fulana"}' http://httpbin/post
Solicitudes JSON

Usamos jo y jq para simplificar el trabajo con JSON.

Para condificar datos de URL-encode (escapar todos los símbolos no permitidos en las URLs), use el –data-urlencode:

curl --data-urlencode "Nombre: Fulana Mengana" http://httpbin/post
Envío de formularios multiparte

POST puede enviar tados como una secuencia de “partes” con un timpo de contenido multipart/form-data. Esto se usa a menudo para formularios HTML que contienen tanto campos de texto y ficheros.

Cada parte tiene un nombre, encabezados, y datos. Las parte se separan por una “frontera mime” (27 guiones e identificador alfanumérico de 16 caracteres), de esta manera:

--------------------------d74496d66958873e
Content-Disposition: form-data; nombre="persona"

Anónimo
--------------------------d74496d66958873e
Content-Disposition: form-data; nombre="secret"; filename="fichero.txt"
Content-Type: text/plain

contenidos del fichero
--------------------------d74496d66958873e--

Para construir estas solicitudes multipartes con curl, usamos –form (F). Cada una de estas opciones agrega una parte a la solicitud:

touch /tmp/fulana.png &&
 
curl -F nombre=Fulana -F edad=25 -F foto=@/tmp/fulana.png
  http://httpbin/post

Redirecciones

Una redirección sucede cuando el servidor, en lugar de devolver el recurso solicitado, le dice al cliente que el recurso está localizado en otro lado (como se indica en el encabezado de Locación). La redirección siempre tiene un código de respuesta 3xx.

Por defecto, Curl no sigue el redireccionamiento, y devuelve una respuesta similar a:

curl -i http://httpbin/redirect/1

Para hacer que Curl sigua redirecciones, use –follow (-L):

curl -L http://httpbin/redirect/1

Para protegerse contra redirecciones en bucle sinfín, use el limitador –max-redirs, por ejemplo:

curl -L --max-redirs 3 http://httpbin/redirect/10

HTTP PUT

A menudo se usa el método PUT para enviar ficheros al servidor. Para esto, use –upload-file (-T):

echo "Hola Tercer Mundo!" > /tmp/hola.txt &&
 
curl -T /tmp/hola.txt http://httpbin/put

En ocasiones, se utiliza PUT para hacer solicitudes a APIs REST. Para ellas, utilice –request (-X) para establecer el método, y –data (-d) para enviar los datos:

curl -X PUT -H "content-type: application/json"
  -d '{"nombre": "fulana"}'
  http://httpbin/put
Cookies

El protocolo HTTP carece de estado, y las cookies fueron concebidas como un método ingenioso para sortear esto, siguiendo este mecanismo general:

  • El servidor desea asociar algún estado con la sesión del cliente.
  • El servidor devuelve el estado en el encabezado de respueta Set-Cookie.
  • El cliente reconoce las cookies y las envía de vuelta con cada solicitud incorporada al encabezado de solicitud de la cookie.

Cada cookie tiene una fecha de vencimiento - ya sea explífita o una de “fin de sesión” (en los clientes de navegación, esto a menudo sucede cuando se cierra el navegador)

Por defecto, Curl ignora las cookies. Para activarlas, use la opción –cookie (-b). Para hacer que curl haga persistir las cookies entre llamadas, use –cookie-jar (-c).

Aunque su reputación ha sido ensuciada por los infames “baneos de cookies”, las cookies siguen siendo uno de los mejores ejemplos de nombrado de funcionalidad.

Aquí el servidor establece la sessionid de cookie al valor 123456 y curl la almacena en el jarro de cookies siguado en /tmp/cookies:

curl -b "" -c /tmp/cookies
  http://httpbin/cookies/set?sessionid=123456
 
&& cat /tmp/cookies

…Las llamadas subsecuentes con -b /tmp/cookies enviarán la cookie con la sessionid indicada de vuelta al servidor.

Curl descarta automáticamente las cookies del jarro de cookies cuando superan su vencimiento (esto requiere una fecha de vencimiento explícita configurada por el servidor). Para desccartar las cookies basadas en sesión, use –junk-session-cookies (-j):

curl -j -b /tmp/cookies http://httpbin/get

Servicios alternativos

El encabezado de respuesta HTTP Alt-Svc indica que existe otra localización de red (un servicio alternativo) que el cliente podría utilizar para solicitudes futuras.

Para permitir los servicios alternativos, use –alt-svc. Esto le dice a curl que almacenee dichos servicios en un fichero especificado, y los considere para solicitudes futuras.

curl --alt-svc /tmp/servicios_alternativos -o /dev/null
  http://httpbin/get
 
&& cat /tmp/servicios_alternativos

Seguridad Estricta de Transporte HTTP

El encabezado de respuesta HTTP Strict-Transport-Security (también conocido como HSTS) informa al cliente que el servidor sólo debe ser accedido a través de HTTPS, y que cualquier intento futuro de accederlo a través de HTTP debe ser convertido a HTTPS automáticamente.

Para hacer que curl respete esta represión impuesta por el HSTS, use –hsts. Esto hará que curl almacene los servidores con HSTS activado en un fichero especificado, y convierta automáticamente las solicitudes http a https cuando las acceda.

curl --hsts /tmp/hsts -o /dev/null
  http://httpbin/get
 
&& cat /tmp/hsts

Curl cuenta con una extensa documentación de referencia. Puedes verla con:

curl --help

Para ver la versión completa del manual, puedes probar con:

curl --manual  | less

Curl es una de las herramientas predilectas para las transferencias electrónicas, e intentar dominarlo en texto-plano.xyz requiere alardearlo con gab:

gab -m "¡Aprendí a usar curl, la “navaja suiza del hacker” en texto-plano.xyz!"
  • tutorial_de_curl.txt
  • Última modificación: 2024/07/06 20:13
  • por peron