Tabla de referencia para codificación y decodificación Base64: ejemplos de comandos en Windows, Linux y Mac

Esta hoja de referencia muestra cómo codificar y decodificar Base64 en Windows, Linux y macOS con certutil, PowerShell y base64, incluyendo las banderas que difieren según el sistema.

Esta guía forma parte de Herramientas de Desarrollo: La guía completa para flujos de trabajo modernos de desarrollo. Base64 mapea cada tres bytes de entrada a cuatro caracteres de A–Z, a–z, 0–9, + y /. La decodificación no necesita ninguna clave: el alfabeto y el carácter de relleno = son suficientes para recuperar los bytes originales.

Linux base64 envuelve en 76 caracteres a menos que se establezca -w 0, macOS base64 escribe una sola línea a menos que -b establezca un salto, y Windows certutil -encode añade bandas de certificado alrededor de las líneas envueltas. Los comandos de Linux a continuación se ejecutaron con GNU coreutils 9.7, uutils coreutils 0.10.0, BusyBox 1.37.0 y OpenSSL 3.5.5. Los comandos de macOS usan las banderas -i, -D y -b documentadas para ese binario desde OS X 10.7.

Codificación y decodificación de Base64 en Windows

Windows no incluye un comando base64. Certutil y PowerShell están integrados.

Usando el símbolo de sistema con Certutil

1. Abre el símbolo de sistema.

2. Codifica un archivo a Base64:

   certutil -encode input.bin output.b64
   

   Reemplaza input.bin con la ruta de tu archivo y output.b64 con el nombre de archivo de salida deseado. El archivo comienza con -----BEGIN CERTIFICATE-----, luego el Base64 envuelto, y después -----END CERTIFICATE-----.

3. Quita las líneas de banda e imprime el cuerpo:

   certutil -encode input.bin tmp.b64 && findstr /v /c:- tmp.b64 && del tmp.b64
   

   findstr /v /c:- elimina cada línea que contenga -, lo que quita las dos bandas. El cuerpo permanece envuelto. PowerShell [Convert]::ToBase64String es el resultado en una línea.

Decodificación de Base64 en Windows (Certutil)

certutil -decode encoded.b64 decoded.bin

certutil -decode acepta el archivo de banda que -encode escribió. También acepta un archivo Base64 en bruto.

Usando PowerShell para codificar y decodificar

PowerShell [Convert]::ToBase64String escribe una sola línea y no añade bandas. Para más automatización de shell, consulta la Hoja de referencia de PowerShell.

Codificar un archivo:

[Convert]::ToBase64String([System.IO.File]::ReadAllBytes("C:\path\to\file.bin"))

Codificar un string (UTF-8):

[Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes("Hello, World!"))
# Output: SGVsbG8sIFdvcmxkIQ==

Encoding.Unicode es UTF-16LE. Los mismos caracteres luego se codifican como SABlAGwAbABvACwAIABXAG8AcgBsAGQAIQA=. Linux base64 de los bytes UTF-8 produce SGVsbG8sIFdvcmxkIQ==.

Decodificar Base64 a string:

[System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String("SGVsbG8sIFdvcmxkIQ=="))
# Output: Hello, World!

Decodificar Base64 a archivo:

[System.IO.File]::WriteAllBytes("decoded.bin", [Convert]::FromBase64String((Get-Content encoded.b64 -Raw)))

FromBase64String acepta espacios, pestañas y saltos de línea. Lanza un error en la banda BEGIN CERTIFICATE, por lo que un archivo de certutil tiene que pasar por certutil -decode (o las bandas tienen que ser eliminadas primero).

Codificación y decodificación de Base64 en Linux

base64 --version nombra el binario en PATH. Una línea que comienza con base64 (GNU coreutils) es de GNU. En Ubuntu 25.10 y 26.04, /usr/bin/base64 es uutils de rust-coreutils; el paquete de 26.04 verificado aquí fue uutils coreutils 0.10.0. GNU coreutils 9.7 es gnubase64 del paquete gnu-coreutils.

Ambos aceptan un archivo posicional, -d / --decode, -i / --ignore-garbage e -w / --wrap. El envoltorio por defecto es 76. -w 0 lo deshabilita. uutils 0.10.0 también trata -D como un alias de -d. GNU coreutils 9.7 sale con invalid option -- 'D' en -D.

Las tuberías y comillas para estas líneas únicas están cubiertas en la Hoja de referencia de Bash.

Codificar un archivo a Base64

base64 input_file > output_file

Ejemplo:

base64 myfile.txt > encoded.txt

Para imprimir el contenido codificado en la terminal:

base64 myfile.txt

Codificar un string a Base64

printf '%s' 'Hello, World!' | base64 -w 0
# Output: SGVsbG8sIFdvcmxkIQ==

printf '%s' escribe los bytes que pasas y se detiene. echo sin -n añade un salto de línea, por lo que el mismo texto se codifica como SGVsbG8sIFdvcmxkIQo=. En bash, echo -n "Hello, World!" | base64 -w 0 coincide con la línea de printf. echo -n no es portable a cada sh.

Deshabilitar el envoltorio de línea (-w 0)

GNU y uutils envuelven en 76 caracteres, incluso cuando stdout es un archivo o una tubería. JSON, variables de entorno, URLs y un valor de data de Kubernetes necesitan una sola línea. La función base64encode() de Terraform devuelve una línea de Base64 estándar, por lo que la salida de CLI que se compara con ella tiene que producirse con el envoltorio deshabilitado:

base64 -w 0 input_file > output_file

Decodificar Base64 en Linux

base64 -d encoded_file > decoded_file
# o
base64 --decode encoded_file > decoded_file

Ejemplo:

printf '%s' 'SGVsbG8sIFdvcmxkIQ==' | base64 -d
# Output: Hello, World!

GNU coreutils desde 9.5, y uutils 0.10.0, decodifican Base64 estándar que omite el relleno =. printf '%s' 'SGVsbG8' | base64 -d imprime Hello. Los codificadores siguen emitiendo el relleno. Los GNU base64 anteriores rechazaban la entrada sin relleno.

-i / --ignore-garbage omite caracteres fuera del alfabeto al decodificar. Los saltos de línea ya están permitidos. Los espacios no lo están, a menos que se establezca -i:

printf '%s' 'SGVs bG8=' | base64 -di
# Output: Hello

En GNU y uutils, -i no toma un nombre de archivo. base64 -i input_file codifica input_file porque el nombre es un argumento posicional y -i solo cambia la decodificación. En macOS, -i es la bandera de archivo de entrada.

OpenSSL

OpenSSL 3.5.5 envuelve en 64 caracteres. -A mantiene la salida en una sola línea:

printf '%s' 'data' | openssl base64 -e -A
# Output: ZGF0YQ==
printf '%s' 'ZGF0YQ==' | openssl base64 -d -A
# Output: data

Sin -A, un búfer largo se parte cada 64 caracteres, que es un ancho diferente al de GNU base64.

BusyBox

BusyBox 1.37.0 acepta -d y -w COL (por defecto 76, 0 deshabilita el envoltorio). --decode falla con unrecognized option '--decode', y -D falla con invalid option -- 'D'. La decodificación ya omite caracteres fuera del alfabeto: printf '%s' 'SGVs!bG8=' | busybox base64 -d imprime Hello. -i es aceptado y no aparece en la línea de ayuda.

Codificación y decodificación de Base64 en macOS

macOS incluye un base64 BSD. Un nombre de archivo se pasa con -i. La redirección de stdin funciona sin -i: base64 < input_file.

Codificar un archivo a Base64

base64 -i input_file > output_file

Ejemplo:

base64 -i myfile.txt > encoded.txt

Para imprimir en la terminal:

base64 -i myfile.txt

El intervalo de salto por defecto es 0, por lo que el texto codificado es una sola línea. -b count inserta un salto de línea cada count caracteres. base64 -w 0 es la opción de Linux; el binario de macOS no la usa. base64 -b 0 -i input_file es la forma explícita de una línea.

Codificar y copiar al portapapeles

base64 -i input_file | pbcopy

Decodificar Base64 en Mac

base64 -D -i encoded_file > decoded_file

-D es decodificar. Estas banderas -i y -D han sido la interfaz de macOS desde OS X 10.7. Un script de Linux que llama a base64 -d debería llamar a base64 -D en macOS.

Banderas por implementación

RFC 4648 obsoleta a RFC 3548. El alfabeto estándar en ambos documentos es A–Z, a–z, 0–9, +, /.

base64 -i file codifica en Linux, porque -i es un booleano allí y file es el operando posicional. El mismo comando en macOS también codifica, porque -i consume file como la ruta de entrada. base64 -D -i file decodifica en macOS y en uutils 0.10.0.

Base64url para JWT

Los segmentos de encabezado y carga útil de JWT usan base64url (sección 5 de RFC 4648): - y _ reemplazan + y /, y el relleno = suele omitirse. El estándar base64 -d luego falla. En uutils 0.10.0 el error es invalid input.

GNU basenc (y gnubasenc en Ubuntu 26.04) acepta la forma sin relleno:

printf '%s' 'aGVsbG8_Ky93b3JsZA' | gnubasenc --base64url -d
# Output: hello?+/world

uutils 0.10.0 basenc --base64url -d requiere que el relleno sea restaurado a un múltiplo de 4. El mismo segmento con == añadido se decodifica. Codifica y quita el relleno para un token estilo JWT:

printf '%s' 'hello?+/world' | basenc --base64url -w 0 | tr -d '='
# Output: aGVsbG8_Ky93b3JsZA

jq decodifica segmentos JWT con @base64d, que es la ruta en Decodificar e imprimir token JWT.

PowerShell puede construir el mismo alfabeto:

$b = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("hello?+/world"))
$b.TrimEnd("=").Replace("+","-").Replace("/","_")

Casos de uso comunes

kubectl create secret codifica en base64 los valores de --from-literal y --from-file por sí mismo. Prefijar el valor con base64 -w 0, como en --from-literal=key=$(base64 -w 0 file.bin), almacena una segunda codificación, y una posterior base64 -d aún devuelve Base64. La Hoja de referencia de Kubernetes usa la forma de texto plano, --from-literal=username=admin.

En un manifiesto, cada valor de data es ya una línea de Base64 estándar, y stringData contiene el string en bruto. El servidor de API fusiona stringData en data. Kubernetes documenta que stringData no funciona bien con apply en el servidor. El objeto es texto codificado; etcd lo almacena sin cifrar a menos que se active el cifrado en reposo.

curl -u escribe el encabezado Authorization: Basic. Construir ese encabezado desde user:pass está cubierto en la Hoja de referencia de cURL.

Cuando falla la decodificación

base64 --version es la comprobación cuando -D o -w se comporta mal. La línea de GNU y la línea de uutils son diferentes, y -D en Linux coincide con la línea de uutils.

Un valor decodificado que termina con una línea vacía incluye un salto de línea de echo. Recodifica esa entrada con printf '%s'.

base64 file | wc -l imprime cuántas líneas envueltas emitió el codificador. Un conteo mayor que 1 en Linux significa que el comando se ejecutó sin -w 0.

invalid input en texto que contiene - o _ es un alfabeto base64url, típico de un segmento JWT. Decodifícalo con basenc --base64url, y en uutils 0.10.0 añade = hasta que la longitud sea un múltiplo de 4.