Kali Linux Mongo-Tools: Instalación y Uso

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

Kali Linux Mongo-Tools: Instalación y Uso

Instalar y usar las mongo-tools en Kali Linux es bastante sencillo, ya que suelen estar disponibles directamente en los repositorios oficiales de Debian/Kali.

Este paquete es esencial porque incluye utilidades fundamentales como mongodump, mongorestore, mongoexport y mongoimport.

1. Instalación

Para obtener las herramientas, abre tu terminal y ejecuta los siguientes comandos:

Actualiza tu lista de paquetes:
Bash
```
sudo apt update
```
Instala el paquete:
Bash
```
sudo apt install mongo-tools
```

2. Herramientas incluidas

Una vez instalado, tendrás acceso a las siguientes utilidades desde la línea de comandos:

Herramienta	Uso principal
`mongodump`	Crea un respaldo binario de los datos de una base de datos.
`mongorestore`	Restaura los datos creados por `mongodump`.
`mongoexport`	Exporta datos en formato JSON o CSV.
`mongoimport`	Importa datos desde archivos JSON, CSV o TSV.
`bsondump`	Convierte archivos BSON en JSON legibles.
`mongostat`	Muestra el estado actual y estadísticas de una instancia de MongoDB.

3. Ejemplo rápido de uso

Si quieres exportar una colección específica a un archivo JSON para analizarla, usarías algo como esto:

Bash

mongoexport --db=nombre_base_datos --collection=usuarios --out=respaldo.json

Nota importante: Ten en cuenta que en versiones muy recientes de MongoDB, algunas de estas herramientas se han separado del núcleo principal. Si necesitas versiones más actualizadas que las que ofrece el repositorio de Kali, lo ideal es descargar los MongoDB Database Tools directamente desde el sitio oficial de MongoDB.

¿Qué estás intentando hacer con las herramientas?

Si me dices si necesitas realizar un pentest (auditoría) sobre una base de datos o simplemente un respaldo, puedo darte los comandos exactos que necesitas.

Para conectar las mongo-tools a una base de datos que requiere autenticación, necesitas pasar las credenciales directamente en el comando. Es un paso crítico en auditorías o administración, ya que sin los permisos adecuados, el servidor rechazará la conexión.

Aquí tienes la estructura y los parámetros clave:

1. Estructura básica de conexión

La forma más común y segura es especificar los parámetros por separado:

Bash

mongodump --host <IP_O_DOMINIO> --port 27017 --username <USUARIO> --password <CONTRASEÑA> --authenticationDatabase admin --db <NOMBRE_DB>

2. Parámetros detallados

--host: La dirección del servidor (por defecto es localhost).
--port: El puerto de escucha (por defecto es 27017).
--username: El nombre de usuario.
--password: La contraseña. Si dejas este espacio en blanco (solo pones --password), la terminal te la pedirá de forma oculta, lo cual es más seguro para que no quede en el historial de comandos.
--authenticationDatabase: Esta es la base de datos donde se creó el usuario (normalmente es admin). Si olvidas este parámetro, la conexión suele fallar.

3. Usando una Cadena de Conexión (URI)

Si tienes un Connection String (como los que da MongoDB Atlas), puedes usarlo directamente con el parámetro --uri. Es mucho más rápido:

Bash

mongoexport --uri="mongodb://usuario:contraseña@localhost:27017/mi_base_datos?authSource=admin" --collection=datos --out=archivo.json

4. Escenario de Auditoría (Pentesting)

Si estás en Kali y has encontrado un MongoDB expuesto pero con autenticación, podrías intentar un ataque de fuerza bruta si no tienes las credenciales, aunque las mongo-tools no son para eso. Para probar la conexión una vez que consigues acceso, usa:

Tip de seguridad: Si estás en una red pública o comprometida, evita escribir la contraseña directamente en el comando. Usa --password al final y presiona Enter para que la terminal te pida el dato de forma privada.

Perfecto, vamos con los comandos específicos para importar datos. Esta es una de las tareas más comunes cuando estás moviendo información de un entorno de pruebas a producción o analizando volcados de datos en Kali.

La herramienta principal para esto es mongoimport.

1. Importar desde un archivo JSON

Si tienes un archivo .json con una lista de documentos, el comando estándar es:

Bash

mongoimport --host localhost --port 27017 --db mi_base_datos --collection clientes --file backup_clientes.json --jsonArray --username mi_usuario --password --authenticationDatabase admin

--jsonArray: CRÍTICO. Úsalo si tu archivo JSON tiene el formato de una lista (empieza con [ y termina con ]). Si no lo pones y el archivo es un array, dará error.

2. Importar desde un archivo CSV

Si los datos vienen de un Excel o una exportación SQL en formato .csv, la estructura cambia un poco:

Bash

mongoimport --db mi_base_datos --collection ventas --type csv --headerline --file datos_ventas.csv --username admin --password

--type csv: Indica explícitamente el formato.
--headerline: Le dice a MongoDB que use la primera línea del archivo CSV como los nombres de los campos (columnas). Si no la tiene, tendrías que usar --fields y listar los nombres manualmente.

3. Modos de Inserción (Upsert)

A veces no quieres simplemente "añadir" datos, sino actualizar los que ya existen. Para eso usamos --mode:

Modo	Descripción
`insert`	(Por defecto) Solo añade nuevos documentos.
`upsert`	Reemplaza documentos existentes que coincidan con un ID o crea nuevos.
`merge`	Combina los campos del archivo con los del documento existente en la BD.

Ejemplo de Upsert:

Bash

mongoimport --db inventario --collection productos --file nuevos_precios.json --mode upsert --upsertFields nombre

(Aquí MongoDB buscará si el "nombre" ya existe; si existe, actualiza el precio; si no, crea el producto).

4. Consejos Pro para Kali Linux

Compresión: Si el archivo es muy grande y está comprimido en .gz, no necesitas descomprimirlo antes. Puedes usar tuberías (pipes):
zcat datos.json.gz | mongoimport --db test --collection logs
Rendimiento: Si vas a importar millones de registros, añade el flag --numInsertionWorkers 4 (o el número de núcleos de tu CPU) para acelerar el proceso.

Automatizar los respaldos en Kali (o cualquier sistema basado en Linux) es una práctica fundamental para no depender de la memoria humana. Vamos a crear un Script de Bash sencillo que haga el trabajo por ti.

1. El Script de Respaldo (`backup_mongo.sh`)

Copia este código en un archivo nuevo. Puedes usar nano backup_mongo.sh en tu terminal:

Bash
#!/bin/bash

# --- CONFIGURACIÓN ---
HOST="localhost"
PORT="27017"
USER="tu_usuario"
PASS="tu_contraseña"
DB_NAME="nombre_de_tu_db"
BACKUP_DIR="/home/kali/backups/mongodb"
FECHA=$(date +%Y%m%d_%H%M%S)

# Crear el directorio de respaldo si no existe
mkdir -p $BACKUP_DIR

# --- EJECUCIÓN DEL RESPALDO ---
echo "Iniciando respaldo de la base de datos: $DB_NAME..."

mongodump --host $HOST --port $PORT --username $USER --password $PASS \
          --authenticationDatabase admin --db $DB_NAME \
          --out $BACKUP_DIR/$FECHA

# Opcional: Comprimir el respaldo para ahorrar espacio
tar -czvf $BACKUP_DIR/backup_$FECHA.tar.gz $BACKUP_DIR/$FECHA
rm -rf $BACKUP_DIR/$FECHA

echo "Respaldo completado con éxito en: $BACKUP_DIR/backup_$FECHA.tar.gz"

2. Dar permisos de ejecución

Para que el sistema te permita correr el script, debes darle permisos:

Bash

chmod +x backup_mongo.sh

3. Automatización con Crontab

Si quieres que este respaldo se ejecute solo (por ejemplo, todos los días a las 2:00 AM), usaremos el programador de tareas de Linux.

Abre el editor de cron:
Bash
```
crontab -e
```
Añade esta línea al final del archivo:
Fragmento de código
```
00 02 * * * /home/kali/backup_mongo.sh
```

Explicación del cron: 00 (minuto) 02 (hora) * * * (todos los días/meses).

4. ¿Cómo restaurar ese respaldo?

Si algo sale mal y necesitas recuperar tus datos desde uno de esos archivos comprimidos:

Descomprime: tar -xzvf backup_2024MMDD_HHMMSS.tar.gz

Restaura:

Bash

mongorestore --db nombre_db --username usuario --password carpeta_descomprimida/nombre_db

Un último consejo de seguridad

En Kali, si dejas la contraseña en texto plano dentro del script (PASS="tu_contraseña"), asegúrate de que nadie más pueda leer ese archivo:

Bash

chmod 700 backup_mongo.sh

(Esto hace que solo tú, el dueño, pueda leerlo y ejecutarlo).

Mantener el disco limpio es tan importante como hacer los respaldos. Si dejas que el script corra indefinidamente, llegará un día en que Kali se quedará sin espacio.

Para solucionar esto, vamos a añadir una función de limpieza a tu script que busque archivos con más de 7 días de antigüedad y los borre automáticamente.

1. El Script con Rotación Automática

He actualizado el script anterior. Ahora incluye una línea mágica con el comando find al final:

Bash
#!/bin/bash

# --- CONFIGURACIÓN ---
DB_NAME="mi_base_datos"
BACKUP_DIR="/home/kali/backups/mongodb"
USER="admin"
PASS="tu_contraseña"
FECHA=$(date +%Y%m%d_%H%M%S)
DIAS_A_MANTENER=7

# 1. Crear directorio
mkdir -p $BACKUP_DIR

# 2. Ejecutar respaldo y comprimir
echo "[$FECHA] Generando backup..."
mongodump --db $DB_NAME --username $USER --password $PASS --authenticationDatabase admin --out $BACKUP_DIR/$FECHA --quiet
tar -czf $BACKUP_DIR/db_backup_$FECHA.tar.gz -C $BACKUP_DIR $FECHA
rm -rf $BACKUP_DIR/$FECHA

# 3. ROTACIÓN: Borrar respaldos más viejos de 7 días
echo "Limpiando archivos antiguos..."
find $BACKUP_DIR -type f -name "*.tar.gz" -mtime +$DIAS_A_MANTENER -exec rm {} \;

echo "Proceso finalizado."

2. ¿Cómo funciona la limpieza?

La línea del find hace lo siguiente:

-type f: Busca solo archivos (no carpetas).
-name "*.tar.gz": Se asegura de borrar solo los respaldos comprimidos.
-mtime +7: Filtra los archivos cuya última modificación fue hace más de 7 días.
-exec rm {} \;: Ejecuta el comando de borrado sobre cada archivo encontrado.

3. Verificación rápida

Para estar seguro de que tu automatización está funcionando, puedes revisar el contenido de tu carpeta de backups de vez en cuando con:

Bash

ls -lh /home/kali/backups/mongodb

Tip de experto: Si estás haciendo esto en un entorno real de auditoría, te recomiendo enviar estos respaldos a una máquina externa o a la nube (usando rclone o scp), porque si la máquina de Kali falla, pierdes el sistema y los respaldos.

Esta es una de las funciones más potentes de mongodump, porque te permite hacer respaldos "quirúrgicos" sin tener que copiar gigabytes de datos innecesarios.

Para lograr esto, utilizaremos el parámetro --query (o -q), que acepta un objeto JSON con la misma sintaxis que usas en el shell de MongoDB.

1. Filtrar por fecha (Usuarios creados hoy)

Si tu colección tiene un campo llamado fecha_creacion (o similar), puedes usar operadores de comparación como $gte (mayor o igual que).

Para respaldar usuarios creados desde el 23 de marzo de 2026:

Bash

mongodump --db mi_base_datos --collection usuarios \
--query '{"fecha_creacion": {"$gte": {"$date": "2026-03-23T00:00:00Z"}}}' \
--out /home/kali/backups/solo_hoy

Nota: Es fundamental usar comillas simples ' fuera del JSON y comillas dobles " dentro, para que la terminal de Linux no se confunda.

2. Otros filtros comunes

Aquí tienes algunos ejemplos que te pueden ser muy útiles en una auditoría o administración:

Objetivo	Filtro (--query)
Solo usuarios activos	`'{"status": "active"}'`
Usuarios con privilegios	`'{"role": "admin"}'`
IDs específicos	`'{"_id": {"$in": [101, 102, 103]}}'`
Campos existentes	`'{"email": {"$exists": true}}'`

3. Ejemplo: Exportar solo "Admins" a un JSON

Si en lugar de un respaldo binario (mongodump), solo quieres una lista rápida en texto para analizarla en Kali con grep o jq, usa mongoexport:

Bash

mongoexport --db corporativo --collection empleados \
--query '{"departamento": "IT", "salario": {"$gt": 5000}}' \
--out empleados_it_high.json

4. Automatización con fechas dinámicas

Si quieres que tu script de respaldo (el que hicimos antes) solo guarde los datos del día actual automáticamente, puedes usar la variable date de Linux dentro del comando:

Bash
# Obtener la fecha de hoy en formato ISO para MongoDB
HOY=$(date -u +"%Y-%m-%dT00:00:00Z")

mongodump --db mi_db --collection ventas \
--query "{\"fecha\": {\"\$gte\": {\"\$date\": \"$HOY\"}}}" \
--out ./backup_diario

(Nota cómo escapamos las comillas \" y el símbolo del dólar \$ para que Bash no intente procesarlos).

Esta es una de las funciones más útiles de mongorestore. Imagina que tienes un respaldo de 50GB pero solo necesitas recuperar una colección que alguien borró por accidente, o peor, solo unos pocos documentos específicos. No necesitas restaurar todo el "monstruo".

Aquí te explico cómo hacer una restauración selectiva sin sobrescribir ni afectar el resto de tus datos operativos.

1. Restaurar una sola Colección

Si tienes una carpeta de respaldo creada con mongodump, verás que dentro hay archivos .bson y .metadata.json para cada colección. Para restaurar solo una (por ejemplo, pedidos):

Bash

mongorestore --db tienda --collection pedidos --username admin --password \
--authenticationDatabase admin /ruta/al/respaldo/tienda/pedidos.bson

2. Restaurar solo "Documentos Faltantes"

Si quieres fusionar los datos del respaldo con los que ya tienes en la base de datos sin borrar lo nuevo, usa el flag --nsInclude.

Pero lo más importante es el comportamiento por defecto: mongorestore no sobrescribe documentos si ya existen con el mismo _id. Solo añade los que faltan.

3. El "Modo Quirúrgico": Restaurar con un Filtro

Si solo quieres restaurar los documentos de un usuario específico desde el respaldo:

Bash

mongorestore --db mi_db --collection usuarios --filter '{"email": "objetivo@correo.com"}' \
/ruta/del/respaldo/mi_db/usuarios.bson

Esto buscará en el archivo binario del respaldo y solo insertará lo que coincida con el filtro.

4. ¿Qué pasa si quiero actualizar datos existentes? (`--drop`)

Por seguridad, mongorestore no borra nada. Si quieres que la colección en la base de datos sea idéntica a la del respaldo (borrando lo que hay ahora y poniendo lo viejo), debes usar --drop:

Bash

mongorestore --db mi_db --collection usuarios --drop /ruta/al/respaldo/mi_db/usuarios.bson

Peligro: El flag --drop elimina la colección actual antes de importar. Úsalo solo si estás seguro de que los datos actuales no sirven.

Resumen de flags para restauraciones precisas:

Parámetro	Función
`--nsInclude`	Define exactamente qué base de datos o colección incluir (ej: `ventas.*`).
`--nsExclude`	Ignora bases de datos o colecciones específicas (ej: `logs.*`).
`--filter`	Restaura solo los documentos que cumplan una condición JSON.
`--drop`	Borra la colección en el destino antes de restaurar.
`--noIndexRestore`	Restaura los datos pero no crea los índices (útil para ahorrar tiempo si vas a indexar después).

Un truco de "Dry Run" (Simulación)

Antes de hacer un desastre en una base de datos de producción, añade --dryRun al final de tu comando.

Bash

mongorestore --db prueba --collection usuarios --drop ./backup --dryRun

Esto te mostrará en la terminal qué es lo que intentaría hacer el comando sin tocar ni un solo byte de la base de datos real.

Comparar un respaldo binario (.bson) con una base de datos activa antes de restaurar es una excelente práctica de seguridad. Como los archivos BSON no se pueden leer con un editor de texto normal (como nano o mousepad), necesitamos herramientas que "traduzcan" ese contenido.

Aquí tienes las tres mejores formas de hacerlo en Kali:

1. Usar `bsondump` para una inspección rápida

Esta herramienta viene incluida en mongo-tools. Convierte el archivo de respaldo a un formato JSON legible que puedes ver en la terminal o filtrar.

Para ver el contenido de un respaldo:

Bash

bsondump /ruta/al/respaldo/mi_db/usuarios.bson | head -n 10

(Esto te muestra los primeros 10 documentos del respaldo para que verifiques la estructura).

Para buscar un usuario específico en el respaldo:

Bash

bsondump /ruta/al/respaldo/mi_db/usuarios.bson | grep "objetivo@correo.com"

2. Comparar usando `mongorestore` con `--dryRun`

Esta es la forma más "profesional". El parámetro --dryRun simula la restauración y te dice exactamente cuántos documentos coinciden, cuántos fallarían y qué índices se crearían, sin escribir nada en el disco.

Bash

mongorestore --db mi_db --collection usuarios --dryRun --verbose /ruta/al/respaldo/mi_db/usuarios.bson

Si activas --verbose, la terminal te dará detalles técnicos de cada conflicto potencial que encuentre entre el respaldo y la base de datos viva.

3. El método de la "Base de Datos Espejo" (Recomendado)

Si el respaldo es muy complejo, lo mejor es restaurarlo en una base de datos temporal dentro del mismo servidor y compararlas usando el shell de MongoDB (mongosh).

Restaurar en una DB temporal:

Bash

mongorestore --db temp_audit /ruta/al/respaldo/mi_db/

Comparar desde el shell:

Entra a mongosh y ejecuta una consulta que busque diferencias. Por ejemplo, para ver qué usuarios están en el respaldo pero no en la base de datos real:

JavaScript
use temp_audit;
var backupUsers = db.usuarios.distinct("email");

use mi_db;
var realUsers = db.usuarios.distinct("email");

// Usuarios que perderíamos si no restauramos:
var desaparecidos = backupUsers.filter(x => !realUsers.includes(x));
printjson(desaparecidos);

Resumen del flujo de trabajo seguro en Kali:

Inspeccionar con bsondump.
Simular con --dryRun.
Validar en una base de datos temporal (temp_audit).
Restaurar solo si los datos coinciden con lo que buscas.

Vamos a crear un script de extracción rápida. La idea es que no tengas que restaurar toda la base de datos solo para ver una lista de correos o nombres que están dentro de un archivo .bson.

Este script usará bsondump y la herramienta jq (que es el estándar en Kali para manipular JSON) para crear un archivo de texto limpio con los campos que elijas.

1. Preparación: Instalar `jq`

Si aún no tienes jq, instálalo rápido:

Bash

sudo apt install jq

2. El Script de Extracción (`extraer_bson.sh`)

Crea el archivo con nano extraer_bson.sh y pega lo siguiente:

Bash
#!/bin/bash

# Comprobar si se pasaron los argumentos necesarios
if [ "$#" -lt 2 ]; then
    echo "Uso: $0 <archivo.bson> <campo1> <campo2> ..."
    echo "Ejemplo: $0 usuarios.bson email nombre"
    exit 1
fi

BSON_FILE=$1
shift # Elimina el primer argumento (el archivo) para quedarse con los campos
FIELDS=$@

echo "------------------------------------------------"
echo "Extrayendo campos: [$FIELDS] desde $BSON_FILE"
echo "------------------------------------------------"

# Procesar con bsondump y jq
# Construimos la cadena de jq dinámicamente
JQ_QUERY=$(echo $FIELDS | sed 's/ / , ./g' | sed 's/^/./')

bsondump "$BSON_FILE" --quiet | jq -r "[ $JQ_QUERY ] | @tsv" > extraccion_datos.txt

echo "Hecho! Los datos se han guardado en: extraccion_datos.txt"
echo "Primeras 5 líneas del resultado:"
head -n 5 extraccion_datos.txt

3. Cómo usarlo

Una vez guardado, dale permisos: chmod +x extraer_bson.sh.

Si tienes un respaldo de usuarios y solo quieres sacar sus emails y sus IDs, ejecutas:

Bash

./extraer_bson.sh /ruta/al/respaldo/usuarios.bson email _id

4. ¿Por qué es útil esto en Kali?

Este flujo es ideal para tareas de OSINT o Análisis Forense:

Sin rastro: No necesitas levantar un servidor MongoDB, por lo que no dejas registros de conexión ni modificas metadatos de una base de datos activa.
Velocidad: Leer un archivo .bson de 1GB y sacar los correos toma segundos, comparado con los minutos que tardaría una restauración completa.
Portabilidad: El resultado es un archivo de texto plano (.txt o .tsv) que puedes pasar fácilmente a herramientas como Hydra, John the Ripper o simplemente un Excel.

Cifrar los respaldos es un paso obligatorio, especialmente en Kali, donde a menudo manejamos datos sensibles de auditorías. Si alguien obtiene acceso a tus archivos .tar.gz o .bson, podría leer toda la base de datos sin necesidad de contraseñas de MongoDB.

Para esto, la herramienta estándar y más robusta es GnuPG (GPG).

1. Cifrado Manual con GPG

La forma más rápida de proteger un archivo de respaldo es mediante cifrado simétrico (con una contraseña).

Para cifrar:

Bash

gpg --symmetric --cipher-algo AES256 backup_20260323.tar.gz

Te pedirá una frase de paso (passphrase).
Se creará un archivo nuevo llamado backup_20260323.tar.gz.gpg.
Importante: Borra el original después: rm backup_20260323.tar.gz.

Para descifrar:

Bash

gpg --output backup_recuperado.tar.gz --decrypt backup_20260323.tar.gz.gpg

2. Integración en tu Script Automático

Podemos modificar el script que hicimos antes para que el cifrado sea parte del proceso y no tengas que escribir la contraseña manualmente cada vez (usando un archivo de clave o una variable).

Versión Ultra-Segura del Script:

Bash
#!/bin/bash
# ... (configuración anterior de mongodump) ...

CLAVE_CIFRADO="MiPasswordSuperSeguro123"
BACKUP_DIR="/home/kali/backups/mongodb"
FECHA=$(date +%Y%m%d)

# 1. Hacer el backup y comprimir
mongodump --db mi_db --out $BACKUP_DIR/$FECHA
tar -czf $BACKUP_DIR/$FECHA.tar.gz -C $BACKUP_DIR $FECHA

# 2. Cifrar el archivo (usando la clave en el script o un archivo)
echo "$CLAVE_CIFRADO" | gpg --batch --yes --passphrase-fd 0 --symmetric --cipher-algo AES256 -c $BACKUP_DIR/$FECHA.tar.gz

# 3. Limpieza: Borrar los archivos NO cifrados
rm -rf $BACKUP_DIR/$FECHA
rm $BACKUP_DIR/$FECHA.tar.gz

echo "Backup cifrado generado: $FECHA.tar.gz.gpg"

3. ¿Por qué usar AES-256?
Shutterstock
Explorar

Cuando usas --cipher-algo AES256, estás aplicando uno de los algoritmos de cifrado más seguros del mundo. Ni siquiera con supercomputadoras actuales se puede romper por fuerza bruta en un tiempo razonable.

4. Alternativa: Cifrado con OpenSSL

Si prefieres no usar GPG, Kali viene con OpenSSL, que también es excelente:

Cifrar: openssl enc -aes-256-cbc -salt -in backup.tar.gz -out backup.tar.gz.enc
Descifrar: openssl enc -d -aes-256-cbc -in backup.tar.gz.enc -out backup_final.tar.gz

Comparativa de Seguridad

Método	Nivel de Seguridad	Uso recomendado
GPG	Muy Alto (Militar)	Respaldos a largo plazo o para enviar por internet.
OpenSSL	Alto	Scripts rápidos y compatibilidad universal.
Zip con Pass	Bajo	No recomendado para datos sensibles en Kali.

Un consejo de peer: Nunca guardes la contraseña del cifrado en el mismo servidor donde están los backups. Si un atacante entra, leerá el script y tendrá la llave. Lo ideal es usar GPG con llaves públicas/privadas, donde tú cifras en el servidor con la llave pública, pero solo puedes descifrar en tu laptop personal con tu llave privada.

El uso de Llaves Públicas y Privadas (Criptografía Asimétrica) es el "estándar de oro". La ventaja es enorme: el servidor donde está Kali puede cifrar los respaldos, pero no puede descifrarlos. Si un atacante hackea ese servidor, encontrará archivos cifrados pero no encontrará la llave para abrirlos, ya que esa llave vive solo en tu computadora personal.

Aquí tienes los pasos para configurar este nivel de seguridad:

1. Generar el par de llaves (En tu PC personal)

No hagas esto en el servidor, hazlo en tu máquina segura.

Bash

gpg --full-generate-key

Elige RSA y RSA (opción 1).
Tamaño de clave: 4096 bits (máxima seguridad).
Sigue los pasos y pon una frase de paso fuerte.

2. Exportar la Llave Pública

Ahora necesitas la "llave de cierre" para llevarla al servidor de Kali:

Bash

gpg --export --armor "tu_email@ejemplo.com" > mi_llave_publica.asc

Luego, sube ese archivo mi_llave_publica.asc a tu servidor Kali (usando scp o un pendrive).

3. Importar la llave en Kali

En tu máquina Kali, importa la llave que acabas de subir:

Bash

gpg --import mi_llave_publica.asc

Para verificar que está ahí: gpg --list-keys.

4. El Script de Respaldo "Blindado"

Ahora modificamos el script para que use tu llave pública. Lo mejor es que ya no necesitas escribir ninguna contraseña en el script.

Bash
#!/bin/bash

# --- CONFIGURACIÓN ---
BACKUP_DIR="/home/kali/backups/mongodb"
FECHA=$(date +%Y%m%d_%H%M%S)
RECEPTOR="tu_email@ejemplo.com" # El email que usaste al crear la llave

# 1. Crear backup binario
mongodump --db mi_base_datos --out $BACKUP_DIR/$FECHA --quiet

# 2. Comprimir y Cifrar con la Llave Pública
# El flag -r (recipient) indica quién puede abrirlo
tar -cf - -C $BACKUP_DIR $FECHA | gpg --encrypt --recipient "$RECEPTOR" --trust-model always > $BACKUP_DIR/backup_$FECHA.tar.gz.gpg

# 3. Limpieza inmediata del archivo temporal
rm -rf $BACKUP_DIR/$FECHA

echo "Respaldo blindado generado: backup_$FECHA.tar.gz.gpg"

5. ¿Cómo recuperar los datos?

Para ver el contenido, tendrás que descargar el archivo .gpg a tu PC personal (donde tienes la Llave Privada) y ejecutar:

Bash

gpg --decrypt backup_20260323.tar.gz.gpg > backup_final.tar.gz

Aquí es donde GPG te pedirá tu frase de paso secreta. Sin esa frase y sin tu archivo de llave privada, los datos son simplemente ruido digital ilegible.

Resumen de la arquitectura de seguridad:

Componente	Ubicación	Función
Llave Pública	Servidor Kali	Solo sirve para CERRAR (cifrar) el candado.
Llave Privada	Tu PC Segura	Sirve para ABRIR (descifrar) el candado.
Frase de Paso	Tu memoria	Protege la Llave Privada en caso de que te roben la PC.

Para cerrar el círculo de una estrategia de respaldo profesional en Kali, vamos a usar Rclone. Es la "navaja suiza" para sincronizar archivos con la nube (Google Drive, Dropbox, AWS S3, OneDrive, etc.) de forma cifrada y segura.

Aquí tienes cómo configurar el envío automático de tus respaldos blindados.

1. Instalar y Configurar Rclone

Primero, instalamos la herramienta en tu Kali:

Bash

sudo apt install rclone

Luego, ejecuta el asistente de configuración:

Bash

rclone config

Elige n para "New remote".
Dale un nombre (ej. mi_nube).
Selecciona tu proveedor (ej. Google Drive es el número 18 generalmente).
Sigue las instrucciones en el navegador para dar permisos.

2. El Script Maestro: Backup + Cifrado + Nube

Ahora integraremos todo en un solo flujo. Este script hace el backup, lo cifra con tu Llave Pública y lo sube a la nube, borrando la copia local para no ocupar espacio.

Bash
#!/bin/bash

# --- CONFIGURACIÓN ---
DB_NAME="mi_base_datos"
BACKUP_DIR="/home/kali/backups/mongodb"
RECEPTOR="tu_email@ejemplo.com"
NUBE_REMOTO="mi_nube:backups_mongo" # 'mi_nube' es el nombre en rclone
FECHA=$(date +%Y%m%d_%H%M%S)

# 1. Crear directorio temporal
mkdir -p $BACKUP_DIR

# 2. Dump, Comprimir y Cifrar en un solo paso (Pipe)
echo "Generando y cifrando respaldo..."
mongodump --db $DB_NAME --archive --quiet | gpg --encrypt --recipient "$RECEPTOR" --trust-model always > $BACKUP_DIR/backup_$FECHA.archive.gpg

# 3. Subir a la Nube
echo "Subiendo a la nube ($NUBE_REMOTO)..."
rclone copy $BACKUP_DIR/backup_$FECHA.archive.gpg $NUBE_REMOTO

# 4. Limpieza: Borrar archivos antiguos en la NUBE (ej. más de 30 días)
rclone delete $NUBE_REMOTO --min-age 30d

# 5. Limpieza local
rm $BACKUP_DIR/backup_$FECHA.archive.gpg

echo "¡Proceso completado! Respaldo seguro en la nube."

3. Ventajas de este Sistema "Blindado"

Zero Knowledge: El proveedor de la nube (Google, Amazon) tiene tu archivo, pero no puede leerlo porque está cifrado con tu llave RSA de 4096 bits.
Espacio Infinito: No te preocupas por llenar el disco de tu máquina Kali.
Resiliencia: Si tu máquina virtual de Kali se corrompe o borras la partición por error, tus datos están a salvo fuera.

4. Verificación

Puedes listar tus respaldos en la nube en cualquier momento desde la terminal de Kali:

Bash

rclone ls mi_nube:backups_mongo

Resumen del Nivel de Seguridad Alcanzado:

Acceso: MongoDB con usuario/password y authDatabase.
Tránsito: Los datos viajan cifrados hacia el backup.
Reposo: Archivo cifrado asimétricamente (RSA-4096).
Disponibilidad: Copia externa en la nube con rotación automática.

Crear un alias es el toque final para que tu flujo de trabajo en Kali sea rápido y profesional. En lugar de recordar rutas largas o nombres de archivos, podrás ejecutar todo con una sola palabra.

Aquí tienes cómo configurar un alias permanente y un pequeño truco extra.

1. Configurar el Alias Permanente

En Kali Linux, el shell por defecto suele ser ZSH (o Bash en versiones antiguas). Vamos a añadir el alias a tu archivo de configuración:

Abre el archivo de configuración (usaremos nano):
Bash
```
nano ~/.zshrc
```
(Si usas Bash, cambia .zshrc por .bashrc).
Ve al final del archivo y añade esta línea (ajusta la ruta a donde guardaste tu script):
Bash
```
alias seguback='/home/kali/scripts/backup_nube.sh'
```
Guarda ( Ctrl+O, Enter) y sal (Ctrl+X).
Para que el cambio surta efecto de inmediato, ejecuta:
Bash
```
source ~/.zshrc
```

Ahora, cada vez que escribas seguback en cualquier terminal, se activará todo el proceso: Dump -> Cifrado RSA -> Subida a la Nube -> Limpieza.

2. Bonus: Notificaciones en el Escritorio

Si quieres que Kali te avise con una ventana emergente cuando el respaldo termine (muy útil si el proceso tarda porque la base de datos es grande), añade esta línea al final de tu script de bash:

Bash

notify-send "MongoDB Backup" "El respaldo cifrado se ha subido a la nube con éxito ✅" --icon=dialog-information

3. Resumen de tu "Kit de Supervivencia" MongoDB en Kali

Has construido un sistema de nivel empresarial partiendo de cero:

Herramienta	Función en tu sistema
`mongo-tools`	Extracción y manipulación de datos.
`GPG (RSA-4096)`	Cifrado asimétrico (nadie lee tus datos sin tu llave privada).
`Rclone`	Sincronización automática con la nube.
`Crontab`	Ejecución programada (el sistema no descansa).
`Alias`	Comodidad y rapidez en la terminal.

En Kali, saber quién está entrando en tu base de datos es la diferencia entre tener un sistema seguro y uno comprometido. MongoDB permite rastrear cada conexión, intento de login fallido y comando ejecutado.

Vamos a configurar y leer los logs de auditoría para que veas qué está pasando "bajo el capó".

1. Activar el Log de Conexiones

Por defecto, MongoDB guarda logs básicos en /var/log/mongodb/mongod.log. Para ver quién se está conectando en tiempo real, usa este comando en una terminal aparte:

Bash

tail -f /var/log/mongodb/mongod.log | grep -E "connection|accepted|authenticate"

2. Configurar el Nivel de Verbosidad (Auditoría Profunda)

Si quieres ver exactamente qué consultas (find, update, delete) está haciendo un usuario, puedes subir el nivel de log desde el shell de MongoDB (mongosh) sin reiniciar el servidor:

JavaScript
// Sube el nivel de log para operaciones de lectura/escritura
db.adminCommand({ setParameter: 1, logLevel: 1 })

3. Analizar Intentos de Fuerza Bruta

Como experto en Kali, te interesa detectar si alguien está intentando adivinar contraseñas. Puedes buscar patrones de error de autenticación (código 18) con este comando:

Bash
grep "AuthenticationFailed" /var/log/mongodb/mongod.log | cut -d' ' -f1-5,10-

Si ves muchas líneas con la misma IP en pocos segundos, es un ataque de fuerza bruta.

4. Crear un Script de "Alerta de Intrusos"

Podemos hacer un pequeño script que te avise si detecta una conexión desde una IP que no sea la tuya:

Bash
#!/bin/bash
MI_IP="192.168.1.50" # Cambia por tu IP
LOG_FILE="/var/log/mongodb/mongod.log"

echo "Monitoreando accesos no autorizados..."

tail -F $LOG_FILE | while read LINE; do
    if echo "$LINE" | grep -q "accepted"; then
        IP_CONEXION=$(echo "$LINE" | grep -oE "\b([0-9]{1,3}\.){3}[0-9]{1,3}\b" | head -1)
        if [ "$IP_CONEXION" != "$MI_IP" ] && [ "$IP_CONEXION" != "127.0.0.1" ]; then
            notify-send "⚠️ ALERTA DE SEGURIDAD" "Conexión detectada desde IP sospechosa: $IP_CONEXION" --urgency=critical
            echo "[$(date)] ALERTA: Acceso desde $IP_CONEXION" >> /home/kali/alertas_mongo.log
        fi
    fi
done

5. Resumen de Monitoreo Profesional

Comando / Herramienta	Qué monitorea
`mongostat`	Rendimiento en vivo (inserts, queries, memoria).
`mongotop`	Qué colecciones están consumiendo más tiempo de lectura/escritura.
`tail -f`	Conexiones y errores de autenticación en tiempo real.
`db.currentOp()`	Operaciones que se están ejecutando ahora mismo en la base de datos.

El "endurecimiento" (Hardening) del archivo mongod.conf es el paso que separa una base de datos vulnerable de una profesional. En Kali, es común que por error dejemos la base de datos expuesta a toda la red, lo cual es un imán para ataques de ransomware.

Vamos a editar el archivo, que normalmente se encuentra en /etc/mongod.conf.

1. Restringir la Interfaz de Red (Bind IP)

Este es el ajuste más importante. Por defecto, MongoDB podría estar escuchando en 0.0.0.0 (todas las interfaces). Debes limitarlo solo a las IPs necesarias.

YAML
# En /etc/mongod.conf
net:
  port: 27017
  bindIp: 127.0.0.1,192.168.1.50  # Solo Localhost y tu IP privada de confianza

127.0.0.1: Permite conexiones desde la misma máquina.
192.168.1.50: (Ejemplo) Permite conexiones solo desde tu IP específica en la red local.
Nunca uses 0.0.0.0 a menos que tengas un Firewall (iptables/ufw) configurado perfectamente.

2. Forzar la Autenticación

Muchos servidores son hackeados porque, aunque tienen usuarios creados, la base de datos permite conexiones sin contraseña. Debes habilitar explícitamente el control de acceso:

YAML
security:
  authorization: enabled

3. Deshabilitar HTTP y Scripts Externos

En versiones modernas esto ya viene desactivado, pero no está de más asegurar que no existan puertas traseras:

YAML
setFreeMonitoring:
  method: "off"

# Evita que se ejecuten funciones de JavaScript del lado del servidor si no las usas
security:
  javascriptEnabled: false

4. Configurar TLS/SSL (Cifrado en tránsito)

Si te vas a conectar desde otra máquina en la red, los datos (y la contraseña) viajan en texto plano a menos que uses certificados.

YAML
net:
  ssl:
    mode: requireSSL
    PEMKeyFile: /etc/ssl/mongodb.pem
    CAFile: /etc/ssl/ca.pem

5. Aplicar los cambios y verificar

Después de editar el archivo con sudo nano /etc/mongod.conf, reinicia el servicio:

Bash

sudo systemctl restart mongod

Ahora, verifica qué puertos están abiertos realmente con una herramienta de Kali:

Bash

sudo netstat -tulpn | grep mongod

Deberías ver que solo escucha en las IPs que definiste en bindIp.

6. Bonus: El Firewall de Kali (UFW)

Incluso con una buena configuración de MongoDB, siempre es mejor tener una segunda capa. Si solo quieres que el puerto 27017 sea accesible desde tu IP de administración:

Bash

sudo ufw allow from 192.168.1.50 to any port 27017
sudo ufw enable

En seguridad, aplicamos el Principio de Menor Privilegio (PoLP). Tener un usuario con el rol root o userAdminAnyDatabase para tareas cotidianas es como ir al supermercado con la llave maestra de la ciudad: si la pierdes, el desastre es total.

Vamos a auditar quién tiene acceso y qué puede hacer realmente.

1. Listar todos los usuarios y sus roles

Entra en tu shell de MongoDB (mongosh) y ejecuta este comando para obtener una radiografía completa de los permisos:

JavaScript
use admin
db.getUsers().forEach(function(u) {
  print("Usuario: " + u.user + " | Roles: " + JSON.stringify(u.roles));
})

2. Identificar "Roles Peligrosos"

Busca usuarios que tengan estos roles, especialmente si no son cuentas de administrador dedicadas:

root: Acceso total y absoluto. Solo debe haber uno (o ninguno, usando roles específicos).
dbAdminAnyDatabase: Puede modificar la estructura de cualquier base de datos.
userAdminAnyDatabase: ¡Cuidado! Este usuario puede crear otros usuarios y asignarse privilegios a sí mismo.
readWriteAnyDatabase: Puede ver y borrar datos en todo el servidor.

3. Detectar privilegios excesivos (Auditoría de Acción)

Si sospechas de un usuario, puedes ver qué acciones específicas tiene permitidas:

JavaScript
db.runCommand({ usersInfo: "nombre_usuario", showPrivileges: true })

Si ves que un usuario de "aplicación" tiene permisos para dropDatabase o shutdown, tienes una brecha de seguridad grave.

4. Cómo "Degradar" un usuario de forma segura

Si encuentras un usuario con demasiados permisos, no lo borres (podrías romper una app). En su lugar, ajusta sus roles.

Ejemplo: Cambiar de dbAdmin a solo readWrite en una base de datos específica:

JavaScript
use admin
db.updateUser("usuario_app", {
  roles: [
    { role: "readWrite", db: "mi_base_datos" } 
  ]
})

Ahora ese usuario ya no puede borrar la base de datos completa ni ver otras bases de datos del sistema.

5. Configurar un "Honeypot" (La trampa)

Ya que mencionaste los puertos antes, una técnica de Kali muy efectiva es dejar un usuario con un nombre tentador (ej. backup_admin) y una contraseña débil, pero sin ningún permiso real.

Si monitorizas los logs y ves intentos de login exitosos con ese usuario, sabrás que alguien ha comprometido tu lista de usuarios antes de que toquen tus datos reales.