Configurar Minicom en Kali Linux

https://www.onlinetis.com/es/

Configurar Minicom en Kali Linux

Configurar Minicom en Kali Linux es un proceso bastante directo. Es la herramienta por excelencia para comunicarte con dispositivos a través del puerto serie (como routers, switches o microcontroladores tipo Arduino).

Aquí tienes una guía rápida para ponerlo en marcha en español:

1. Instalación

Lo primero es asegurarte de que la herramienta esté instalada. Abre tu terminal y ejecuta:

Bash

sudo apt update && sudo apt install minicom -y

2. Identificar tu dispositivo

Antes de abrir Minicom, necesitas saber en qué puerto está conectado tu dispositivo. Conéctalo y escribe:

Bash

ls /dev/tty*

Tip: Generalmente aparecerá como /dev/ttyUSB0 o /dev/ttyS0. Si no estás seguro, desconecta el cable, corre el comando, conéctalo y córrelo de nuevo; el que aparezca es el tuyo.

3. Configuración Inicial

Para que Minicom funcione correctamente (velocidad de baudios, paridad, etc.), debes entrar al menú de configuración:

Bash

sudo minicom -s

Pasos dentro del menú:

Baja hasta Configuración de la puerta serial (Serial port setup).
Presiona A para cambiar el dispositivo (ej. /dev/ttyUSB0).
Presiona E para ajustar la velocidad (Bps/Par/Bits). Lo común es 9600 8N1.
Presiona F para desactivar el "Hardware Flow Control" (Control de flujo por hardware) a No, ya que suele dar problemas si no se necesita.
Pulsa Enter para salir de ese submenú.
Selecciona Save setup as dfl (Guardar configuración como predeterminada).
Selecciona Salir de Minicom.

4. Uso de Minicom

Una vez configurado, simplemente lánzalo con:

Bash

sudo minicom

Atajos esenciales (Comandos de escape):

Minicom funciona mediante combinaciones de teclas. Casi todas empiezan con Ctrl + A.

Ctrl + A, luego Z: Abre el menú de ayuda (donde verás todas las opciones).
Ctrl + A, luego X: Salir del programa.
Ctrl + A, luego L: Guardar la sesión en un archivo de log.
Ctrl + A, luego C: Limpiar la pantalla.

Solución de problemas comunes

Permiso denegado: Si no quieres usar sudo siempre, añade tu usuario al grupo dialout:
sudo usermod -a -G dialout $USER (luego reinicia sesión).
Pantalla "congelada": Revisa que el Hardware Flow Control esté en No en la configuración.

Vamos a crear un script sencillo en Bash. Esto te ahorrará tener que recordar el puerto o configurar el menú cada vez que conectes un dispositivo específico.

Lo haremos de forma que el script busque automáticamente el puerto USB (por si cambia de ttyUSB0 a ttyUSB1) y lance Minicom con los parámetros ideales.

Script: `conectar_serial.sh`

Copia este código en tu terminal:

Bash
cat << 'EOF' > conectar_serial.sh
#!/bin/bash

# --- Configuración ---
# Puedes cambiar 9600 por la velocidad que necesites (115200 es común también)
BAUDIOS="9600"
PUERTO=$(ls /dev/ttyUSB* 2>/dev/null | head -n 1)

# Verificar si hay algún dispositivo conectado
if [ -z "$PUERTO" ]; then
    echo "❌ Error: No se detectó ningún dispositivo en /dev/ttyUSB*"
    exit 1
fi

echo "🚀 Conectando a $PUERTO a $BAUDIOS baudios..."

# Ejecutar minicom con parámetros:
# -D: Especifica el puerto
# -b: Especifica la velocidad (baud rate)
# -o: No inicializar (evita códigos de control de modem raros)
sudo minicom -D "$PUERTO" -b "$BAUDIOS" -o
EOF

Cómo prepararlo y usarlo

Dale permisos de ejecución:
Bash
```
chmod +x conectar_serial.sh
```
Ejecútalo cuando lo necesites:
Bash
```
./conectar_serial.sh
```

¿Qué hace este script exactamente?

Auto-detección: Busca cualquier dispositivo que empiece por ttyUSB y toma el primero que encuentre.
Modo Directo: Al usar el flag -o, Minicom entra directamente a la terminal sin intentar "llamar" al dispositivo como si fuera un módem antiguo.
Portabilidad: Si mañana conectas el cable en otro puerto USB y el sistema lo asigna como ttyUSB1, el script lo encontrará solo.

Vamos a darle un toque más profesional. He modificado el script para que sea interactivo: te preguntará qué velocidad quieres usar (con una opción por defecto para ir rápido) y verificará si tienes los permisos adecuados.

Copia y pega este bloque en tu terminal de Kali:

Bash
cat << 'EOF' > conectar.sh
#!/bin/bash

# --- Colores para la terminal ---
VERDE='\033[0;32m'
AZUL='\033[0;34m'
ROJO='\033[0;31m'
NC='\033[0m' # Sin color

echo -e "${AZUL}--- Asistente de Conexión Serial ---${NC}"

# 1. Buscar puertos disponibles
PUERTOS=$(ls /dev/ttyUSB* /dev/ttyACM* 2>/dev/null)

if [ -z "$PUERTOS" ]; then
    echo -e "${ROJO}❌ No se encontraron dispositivos USB Serial (ttyUSB o ttyACM).${NC}"
    exit 1
fi

echo -e "Puertos detectados:"
select PUERTO in $PUERTOS; do
    if [ -n "$PUERTO" ]; then
        break
    else
        echo "Selección no válida."
    fi
done

# 2. Seleccionar Velocidad (Baud Rate)
echo -e "\n${AZUL}Selecciona la velocidad (Enter para 9600):${NC}"
echo "1) 9600"
echo "2) 115200"
echo "3) Otra personalizada"
read -p "Opción: " OPT_BAUD

case $OPT_BAUD in
    2) BAUD="115200" ;;
    3) read -p "Introduce la velocidad: " BAUD ;;
    *) BAUD="9600" ;;
esac

echo -e "\n${VERDE}🚀 Conectando a $PUERTO a $BAUD baudios...${NC}"
echo -e "${AZUL}Tip: Presiona Ctrl+A y luego X para salir.${NC}\n"

# 3. Ejecutar Minicom
# -D: Puerto, -b: Baudios, -o: Saltar inicialización de modem, -w: Ajuste de línea
sudo minicom -D "$PUERTO" -b "$BAUD" -o -w
EOF

Cómo usar este nuevo script:

Dale permisos:
Bash
```
chmod +x conectar.sh
```
Lánzalo:
Bash
```
./conectar.sh
```

¿Qué mejoras incluye?

Menú de selección: Si tienes varios cables conectados (ej. un Arduino y un Router), te deja elegir cuál usar.
Soporte ttyACM: Algunos dispositivos modernos (como las placas STM32 o Raspberry Pi Pico) aparecen como /dev/ttyACM0 en lugar de ttyUSB0. Este script busca ambos.
Velocidades comunes: Te permite elegir rápidamente entre 9600 y 115200, que cubren el 90% de los casos en hacking de hardware.
Ajuste de línea (-w): He añadido el flag -w para que, si el dispositivo envía líneas de texto muy largas, Minicom las ajuste automáticamente a tu ventana sin cortarlas.

Crear un alias es como darle un "superpoder" a tu terminal: en lugar de buscar la carpeta donde guardaste el script y escribir ./conectar.sh, simplemente escribirás serie (o el nombre que prefieras) y el asistente se lanzará al instante desde cualquier lugar.

Aquí tienes cómo hacerlo de forma permanente en Kali Linux:

Pasos para crear el alias

Mueve el script a una carpeta segura:
Para que no borres el script por accidente, vamos a moverlo a una carpeta oculta en tu usuario:
Bash
```
mkdir -p ~/.scripts
mv conectar.sh ~/.scripts/conectar.sh
chmod +x ~/.scripts/conectar.sh
```
Configura el alias en tu archivo de terminal:
Kali usa Zsh por defecto, así que editaremos el archivo .zshrc. Ejecuta este comando (es una sola línea):
Bash
```
echo "alias serie='bash ~/.scripts/conectar.sh'" >> ~/.zshrc
```
Aplica los cambios ahora mismo:
Para no tener que cerrar y abrir la terminal, carga la nueva configuración con:
Bash
```
source ~/.zshrc
```

¿Cómo se usa ahora?

¡Pruébalo! Simplemente escribe en tu terminal:

Bash

serie

Y verás cómo aparece el menú de selección de puerto y velocidad que configuramos antes.

Tips Pro para Kali:

Si prefieres otro nombre: Puedes cambiar serie por terminal, com o lo que te resulte más cómodo repitiendo el paso 2 con el nombre nuevo.
Limpieza: Si alguna vez quieres quitarlo, solo tienes que abrir el archivo con nano ~/.zshrc, ir al final de todo, borrar la línea del alias y guardar.

En auditorías de seguridad o cuando estás haciendo debugging de hardware, tener un registro (log) de todo lo que entra y sale por la consola es vital. Si algo falla o el dispositivo se reinicia, tendrás el texto guardado para analizarlo después.

Vamos a modificar el script para que cree una carpeta llamada logs_serial en tu carpeta personal y guarde cada sesión con la fecha y hora exacta.

Script Actualizado (con Auto-Logging)

Copia este código y sobreescribe el archivo anterior:

Bash
cat << 'EOF' > ~/.scripts/conectar.sh
#!/bin/bash

# --- Configuración de Logs ---
DIRECTORIO_LOGS="$HOME/logs_serial"
mkdir -p "$DIRECTORIO_LOGS"
FECHA=$(date +"%Y-%m-%d_%H-%M-%S")
ARCHIVO_LOG="$DIRECTORIO_LOGS/log_$FECHA.txt"

# --- Colores ---
VERDE='\033[0;32m'
AZUL='\033[0;34m'
ROJO='\033[0;31m'
NC='\033[0m'

echo -e "${AZUL}--- Asistente Serial con Auto-Log ---${NC}"

# 1. Buscar puertos
PUERTOS=$(ls /dev/ttyUSB* /dev/ttyACM* 2>/dev/null)
if [ -z "$PUERTOS" ]; then
    echo -e "${ROJO}❌ No se detectó hardware serial.${NC}"
    exit 1
fi

echo -e "Selecciona el dispositivo:"
select PUERTO in $PUERTOS; do
    [ -n "$PUERTO" ] && break
done

# 2. Seleccionar Velocidad
echo -e "\n${AZUL}Velocidad (Enter para 9600):${NC}"
read -p "Opción (9600/115200/otro): " BAUD
[ -z "$BAUD" ] && BAUD="9600"

echo -e "\n${VERDE}🚀 Conectando a $PUERTO...${NC}"
echo -e "📝 Guardando log en: ${AZUL}$ARCHIVO_LOG${NC}"

# 3. Ejecutar Minicom con captura de log
# -C: Indica el archivo donde se guardará la captura
sudo minicom -D "$PUERTO" -b "$BAUD" -o -w -C "$ARCHIVO_LOG"
EOF

¿Cómo funciona ahora?

Escribes serie en cualquier terminal.
Eliges el puerto y la velocidad.
Minicom se abre normal, pero en segundo plano está escribiendo todo en un archivo .txt.
Cuando cierres Minicom (Ctrl+A -> X), el log se cerrará automáticamente.

Cómo ver tus logs después

Si quieres revisar lo que pasó en una sesión anterior, solo tienes que ir a la carpeta:

Bash

cd ~/logs_serial
ls -lh
cat log_2026-03-23_12-30-00.txt  # (Ejemplo de nombre)

Dato curioso: Kali Linux es muy potente para esto porque puedes combinar estos logs con herramientas de análisis de texto como grep para buscar errores específicos (ej. grep "ERROR" log_*.txt).

Transferir archivos a través de una conexión serial es una técnica clásica (y a veces la única opción) cuando trabajas con equipos que no tienen red, como routers antiguos, switches industriales o sistemas embebidos.

Los protocolos más comunes son Xmodem, Ymodem y Zmodem. Aquí te explico cómo hacerlo paso a paso desde el script que ya tenemos.

1. Preparación: Instalar las herramientas de envío

Minicom utiliza un paquete externo llamado lrzsz para gestionar estas transferencias. En Kali suele venir, pero asegúrate con este comando:

Bash

sudo apt update && sudo apt install lrzsz -y

2. Cómo enviar un archivo (Paso a Paso)

Una vez que estés dentro de tu sesión de Minicom (usando tu comando serie):

Inicia el comando en el dispositivo: Si estás actualizando un firmware, el dispositivo suele tener un comando tipo load xmodem o copy xmodem flash. Ejecútalo primero.
Llama al menú de envío en Minicom: Presiona Ctrl + A y luego la tecla S (de Send).
Selecciona el protocolo: Aparecerá una lista.
- Xmodem: El más básico y compatible.
- Ymodem: Más rápido y permite enviar el nombre del archivo.
- Zmodem: El mejor; detecta errores y puede reanudar descargas.
Selecciona el archivo: Se abrirá un explorador de archivos rudimentario en la terminal. Usa las flechas para navegar y la tecla Espacio (dos veces) para entrar en carpetas o seleccionar el archivo.
Pulsa Enter: Verás una barra de progreso indicando la transferencia.

3. Cómo recibir un archivo

Si quieres "sacar" un archivo del dispositivo hacia tu Kali:

En el dispositivo, ejecuta el comando de envío (ej. export config.txt).
En Minicom, presiona Ctrl + A y luego la tecla R (de Receive).
Selecciona el protocolo que coincida con lo que el dispositivo está usando.
El archivo se guardará automáticamente en la carpeta desde donde lanzaste el script (o en la carpeta de descargas configurada en Minicom).

Un truco extra: "Paste File"

Si solo quieres enviar un script de configuración (texto plano) sin protocolos complicados, hay una forma más rápida:

Presiona Ctrl + A y luego Y.
Selecciona el archivo de texto.
Minicom "escribirá" el contenido del archivo línea por línea como si lo estuvieras tecleando tú mismo a toda velocidad.

Mantener una carpeta dedicada para las transferencias es una práctica de "higiene digital" que te ahorrará mucho tiempo buscando archivos de configuración o firmwares perdidos entre tus logs.

Vamos a actualizar tu script para que:

Cree automáticamente una carpeta ~/transferencias_serial.
Configure Minicom para que, por defecto, busque y guarde ahí cualquier archivo enviado o recibido por X/Y/Zmodem.

Script Actualizado (con Directorio de Transferencia)

Ejecuta este comando para actualizar el archivo en tu carpeta de scripts:

Bash
cat << 'EOF' > ~/.scripts/conectar.sh
#!/bin/bash

# --- Configuración de Carpetas ---
DIR_LOGS="$HOME/logs_serial"
DIR_TRANS="$HOME/transferencias_serial"

mkdir -p "$DIR_LOGS" "$DIR_TRANS"

FECHA=$(date +"%Y-%m-%d_%H-%M-%S")
ARCHIVO_LOG="$DIR_LOGS/log_$FECHA.txt"

# --- Colores ---
VERDE='\033[0;32m'
AZUL='\033[0;34m'
ROJO='\033[0;31m'
NC='\033[0m'

echo -e "${AZUL}--- Terminal Serial Pro (Logs + Transferencias) ---${NC}"

# 1. Buscar puertos
PUERTOS=$(ls /dev/ttyUSB* /dev/ttyACM* 2>/dev/null)
if [ -z "$PUERTOS" ]; then
    echo -e "${ROJO}❌ No se detectó hardware serial.${NC}"
    exit 1
fi

echo -e "Selecciona el dispositivo:"
select PUERTO in $PUERTOS; do
    [ -n "$PUERTO" ] && break
done

# 2. Seleccionar Velocidad
echo -e "\n${AZUL}Velocidad (Enter para 9600):${NC}"
read -p "Opción: " BAUD
[ -z "$BAUD" ] && BAUD="9600"

echo -e "\n${VERDE}🚀 Conectando a $PUERTO...${NC}"
echo -e "📁 Transferencias en: ${AZUL}$DIR_TRANS${NC}"
echo -e "📝 Log activo en: ${AZUL}$ARCHIVO_LOG${NC}"

# 3. Ejecutar Minicom con flags avanzados
# -D: Puerto, -b: Baudios, -o: Sin inicializar modem, -w: Wrap líneas
# -C: Archivo de log
# -p: Carpeta de descarga (download directory)
# -u: Carpeta de subida (upload directory)
sudo minicom -D "$PUERTO" -b "$BAUD" -o -w -C "$ARCHIVO_LOG" -p "$DIR_TRANS" -u "$DIR_TRANS"
EOF

¿Cómo aprovechar esta carpeta ahora?

Ahora, cuando uses los atajos de transferencia dentro de Minicom, la experiencia será mucho más fluida:

Para Subir (Ctrl+A -> S): Cuando se abra el selector de archivos, Minicom te mostrará directamente el contenido de ~/transferencias_serial. Solo tienes que mover allí tus archivos de firmware antes de empezar.
Para Bajar (Ctrl+A -> R): Cualquier archivo que el dispositivo te envíe aparecerá automáticamente en esa carpeta, sin preguntarte dónde guardarlo.

Un último consejo de "pro":

Si alguna vez el dispositivo se queda "mudo" después de conectar, recuerda que a veces es necesario presionar Enter un par de veces para que el dispositivo despierte y te muestre el prompt de inicio de sesión.

Buscar este blog