Sin scp/sftp, convierte el binario a texto ASCII, pásalo por la terminal y recupéralo:

1
2
3
4
5

# Origen: binario -> texto
base64 archivo.bin          # imprime; copia la salida

# Destino: texto -> binario (pega el bloque, Ctrl-D cierra)
base64 -d > archivo.bin

Verifica siempre con un hash en ambos lados (sha256sum archivo.bin). Si no coincide, el pegado perdió bytes.

Para qué sirve

A veces solo tienes una shell: una sesión Telnet a un equipo viejo, una consola serie, un ssh a una jaula sin scp, un contenedor mínimo sin herramientas de red, o un KVM/IPMI donde solo puedes teclear. No hay transferencia de archivos, pero sí puedes escribir y leer texto.

El truco: cualquier archivo —incluso binario— se puede representar como texto ASCII imprimible. Lo codificas en el origen, copias el texto por la terminal, y lo decodificas en el destino. Dos herramientas hacen esto: base64 (moderna, en todas partes) y uuencode (clásica, de los tiempos de UUCP y Usenet).

Opción 1: base64 (recomendada)

base64 viene en coreutils, así que está en prácticamente cualquier Linux/BSD/macOS moderno.

En el origen — codifica y muestra el texto:

1

base64 archivo.bin

Para un archivo grande, mándalo a un .txt y ábrelo, o imprime en una sola línea sin saltos:

1

base64 -w0 archivo.bin        # -w0 = sin wrap, una sola línea (GNU)

Copia toda la salida (es texto imprimible, seguro de pegar).

En el destino — pega el texto y decodifica:

1
2

base64 -d > archivo.bin
# pega aquí el bloque base64, luego Enter y Ctrl-D para cerrar la entrada

Ctrl-D marca fin de entrada (EOF) y base64 -d escribe el binario reconstruido.

En macOS/BSD el flag para una sola línea no es -w0. Usa base64 -i archivo.bin para codificar y base64 -D (D mayúscula) para decodificar. Si dudas, base64 --help.

Opción 2: uuencode / uudecode (clásica)

uuencode/uudecode vienen en el paquete sharutils. Es lo que se usaba para mandar binarios por correo y Usenet antes de MIME. Útil si estás en un sistema viejo que ya lo trae y no tiene base64.

1
2
3

# instala si hace falta
sudo apt install sharutils        # Debian/Ubuntu
sudo dnf install sharutils        # Fedora/RHEL

En el origen — el segundo argumento es el nombre que tendrá el archivo al decodificar:

1

uuencode archivo.bin archivo.bin

Imprime un bloque que empieza con begin 644 archivo.bin y termina en end. Copia todo, incluidas esas dos líneas.

En el destino — pega el bloque y decodifica:

1
2

uudecode > /dev/null
# pega el bloque (begin ... end), luego Ctrl-D

uudecode lee el nombre del propio bloque (begin 644 archivo.bin) y crea archivo.bin solo. No necesitas indicar el nombre de salida.

Verifica SIEMPRE con un hash

Pegar texto largo en una terminal es frágil: un buffer que se corta, un carácter perdido, un wrap que mete un espacio. Comprueba que el archivo llegó íntegro:

1
2

# en ambos lados
sha256sum archivo.bin

Si los hashes no coinciden, el pegado se corrompió. Repite, o parte el archivo (abajo).

Comprime antes de codificar

base64 agranda el archivo ~33%. Si lo comprimes primero, hay menos texto que pegar — y de paso empacas una carpeta entera en un solo archivo. Comprime, codifica, y del otro lado inviertes el orden: decodifica, descomprime.

Un archivo con gzip (o bzip2 / xz, mejor ratio y más lentos):

1
2
3
4
5
6
7
8
9

# origen
gzip -c archivo.bin | base64 -w0        # comprime y codifica en un solo paso
# bzip2 -c archivo.bin | base64 -w0     # suele comprimir más
# xz   -c archivo.bin | base64 -w0      # el que más comprime (más lento)

# destino: decodifica y descomprime
base64 -d | gzip -d > archivo.bin       # pega el texto, Ctrl-D
# base64 -d | bzip2 -d > archivo.bin
# base64 -d | xz   -d > archivo.bin

Una carpeta entera con tar (empaca + comprime + codifica):

1
2
3
4
5
6

# origen
tar czf - carpeta/ | base64 -w0         # c=crear z=gzip f=-  ->  a stdout
# tar cjf - carpeta/  = bzip2 ;  tar cJf - carpeta/  = xz

# destino: decodifica, descomprime y extrae
base64 -d | tar xzf -                    # pega el texto, Ctrl-D

Verifica con sha256sum el tar.gz (no el contenido suelto) en ambos lados: es más fácil comparar un solo archivo que una carpeta.

Archivos grandes: pártelos

Pegar megabytes de texto en una terminal es pedir problemas. Si tras comprimir sigue grande, divide antes de codificar:

1
2
3
4
5
6
7

# origen
split -b 100k archivo.bin parte_        # crea parte_aa, parte_ab, ...
base64 parte_aa                          # pasa cada parte por separado

# destino: reconstruye cada parte y únelas
cat parte_aa parte_ab parte_ac > archivo.bin
sha256sum archivo.bin                    # verifica contra el origen

Qué hace cada pieza

Traps

• Siempre verifica con hash. Es el único seguro contra un pegado truncado. Sin esto, crees que copiaste y tienes basura.
• El tamaño crece ~33–35%. base64 agrega ~33%, uuencode ~35%. Un binario de 3 MB son ~4 MB de texto que teclear/pegar. Para eso está split.
• Flags distintos en macOS/BSD vs GNU. -w0/-d son GNU; en macOS es -i/-D. No asumas.
• Cuidado con el auto-wrap del cliente de terminal. Algunos clientes Telnet/serie insertan saltos o cortan líneas largas. Si falla, usa base64 con wrap (sin -w0) y bloques más chicos.
• Telnet va en claro. Si pasas algo sensible por Telnet, va sin cifrar por la red. Úsalo solo en consolas locales/serie o redes de confianza; para todo lo demás, SSH.
• No es para TB. Esto es para rescatar un archivo cuando no hay otra vía, no para mover volúmenes. Si puedes usar scp/rsync/sftp, úsalos.

See also

• SSH a Windows Server 2003 con Bitvise