Configurar MySQL/MariaDB en Kali

 

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

Configurar MySQL/MariaDB en Kali

Entiendo que estás buscando configurar o entender el paquete mysql-defaults en Kali Linux, probablemente porque te has topado con alguna configuración en inglés o necesitas ajustar el entorno de base de datos.

En Kali Linux (basado en Debian), el paquete mysql-defaults no es una base de datos en sí, sino un conjunto de archivos de configuración que apuntan a la implementación predeterminada de MySQL, que en la actualidad suele ser MariaDB.

Aquí tienes una guía rápida para manejar esto en español:

1. ¿Qué es mysql-defaults?

Es un paquete de metadatos. Su función principal es asegurar que, cuando instales MySQL, el sistema sepa qué archivos de configuración (my.cnf) usar y dónde encontrarlos. En Kali, esto generalmente redirige a /etc/mysql/mariadb.conf.d/.

2. Instalación y Configuración Básica

Si aún no tienes instalado el servidor, puedes hacerlo con:

Bash
sudo apt update
sudo apt install default-mysql-server

3. Cambiar el idioma de los mensajes de error

Si lo que buscas es que los errores de la base de datos aparezcan en español, debes editar el archivo de configuración principal:

  1. Abre el archivo de configuración:

    sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf

  2. Busca la sección [mysqld] y añade o modifica la siguiente línea:

    lc-messages-dir = /usr/share/mysql

    lc-messages = es_ES

  3. Guarda (Ctrl+O) y sal (Ctrl+X).

  4. Reinicia el servicio:

    sudo systemctl restart mariadb

4. Comandos útiles en español

AcciónComando
Iniciar serviciosudo systemctl start mariadb
Estado del serviciosudo systemctl status mariadb
Entrar a la consolasudo mysql -u root -p
Asegurar instalaciónsudo mysql_secure_installation

Nota de seguridad: Kali Linux está diseñado para pruebas de penetración. Si usas MariaDB/MySQL para un proyecto permanente, asegúrate de correr el comando mysql_secure_installation para eliminar usuarios anónimos y deshabilitar el login remoto de root.

 

Automatizar estas tareas te ahorrará mucho tiempo, especialmente si estás configurando laboratorios de pruebas en Kali.

Aquí tienes un script básico en Bash que hace el trabajo pesado por ti. Este script crea una base de datos, un usuario específico y le otorga todos los permisos necesarios.

Script de Automatización (crear_db.sh)

Bash
#!/bin/bash

# Configuración de variables
DB_NAME="mi_laboratorio"
DB_USER="pentester"
DB_PASS="PasswordSegura123!"

echo "--- Iniciando configuración de Base de Datos ---"

# Ejecutar comandos de MySQL
sudo mysql -e "CREATE DATABASE IF NOT EXISTS ${DB_NAME};"
sudo mysql -e "CREATE USER IF NOT EXISTS '${DB_USER}'@'localhost' IDENTIFIED BY '${DB_PASS}';"
sudo mysql -e "GRANT ALL PRIVILEGES ON ${DB_NAME}.* TO '${DB_USER}'@'localhost';"
sudo mysql -e "FLUSH PRIVILEGES;"

echo "-----------------------------------------------"
echo "Éxito: Base de datos '${DB_NAME}' creada."
echo "Usuario: ${DB_USER}"
echo "-----------------------------------------------"

Cómo usarlo:

  1. Crea el archivo: nano crear_db.sh (pega el código de arriba).

  2. Dale permisos de ejecución: chmod +x crear_db.sh

  3. Ejecútalo: ./crear_db.sh

Estructura de permisos en MySQL

Para entender qué acabamos de hacer con el script, aquí tienes una representación de cómo se jerarquizan los permisos:

  • Global: Permisos en todo el servidor.

  • Database: Permisos solo en mi_laboratorio.

  • Table/Column: Control granular (poco común en laboratorios rápidos).

¿Qué sigue?

Si prefieres algo más avanzado, puedo mostrarte cómo conectar este entorno con un script de Python usando mysql-connector-python para insertar datos automáticamente desde un archivo de texto o un diccionario.

 

Entendido, vamos a darle un toque más profesional y robusto al script de Bash. Para que sea realmente útil en un entorno de Kali, es buena idea añadir interactividad (para no dejar contraseñas en texto plano en el código) y verificación de errores.

Aquí tienes una versión mejorada que incluye:

  1. Entrada dinámica: Te pregunta el nombre y la clave en el momento.

  2. Validación de privilegios: Revisa si eres root antes de intentar ejecutar nada.

  3. Limpieza visual: Borra la pantalla y usa colores para que los mensajes de éxito o error sean claros.

Script Avanzado (setup_db.sh)

Bash
#!/bin/bash

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

# 1. Verificar si el usuario es root
if [ "$EUID" -ne 0 ]; then 
  echo -e "${ROJO}Error: Por favor, ejecuta este script con sudo.${NC}"
  exit 1
fi

echo -e "${VERDE}--- Configuración de Base de Datos Interactiva ---${NC}"

# 2. Solicitar datos al usuario
read -p "Nombre de la base de datos: " DB_NAME
read -p "Nombre del nuevo usuario: " DB_USER
read -s -p "Contraseña para el usuario: " DB_PASS
echo -e "\n"

# 3. Ejecutar comandos en MariaDB/MySQL
echo "Configurando..."

mysql -e "CREATE DATABASE IF NOT EXISTS \`${DB_NAME}\`;"
mysql -e "CREATE USER IF NOT EXISTS '${DB_USER}'@'localhost' IDENTIFIED BY '${DB_PASS}';"
mysql -e "GRANT ALL PRIVILEGES ON \`${DB_NAME}\`.* TO '${DB_USER}'@'localhost';"
mysql -e "FLUSH PRIVILEGES;"

# 4. Confirmación final
if [ $? -eq 0 ]; then
    echo -e "${VERDE}✔ Éxito: Todo se ha configurado correctamente.${NC}"
    echo -e "Base de datos: ${DB_NAME}"
    echo -e "Usuario: ${DB_USER}"
else
    echo -e "${ROJO}✘ Error: Hubo un problema al ejecutar los comandos de SQL.${NC}"
fi

¿Qué cambió y por qué es mejor?

  • Comillas invertidas (`): En el comando CREATE DATABASE \${DB_NAME}`;`, las usamos por si decides ponerle un nombre a la DB que contenga guiones o espacios (aunque no sea recomendable).

  • Variable $EUID: Es una forma segura de verificar que tienes permisos de administrador antes de que el script falle a mitad de camino.

  • Flag -s en read: Esto hace que cuando escribas la contraseña, no se vea en la pantalla (modo "silencioso"), lo cual es una práctica básica de seguridad.

  • Variable $?: Revisa el "exit status" del último comando. Si es 0, todo salió bien.

Próximo paso sugerido

Este script crea el usuario solo para acceso local (localhost). Si estás usando esta DB para una herramienta que corre en otra máquina o en un contenedor, necesitarías cambiar localhost por % o una IP específica.

 

Para habilitar el acceso remoto, no solo necesitamos que el usuario de la base de datos tenga permisos para conectarse desde cualquier lugar (el símbolo %), sino que también debemos decirle a MariaDB que deje de "escuchar" solo las conexiones internas de tu propia máquina.

Aquí tienes los dos pasos necesarios para completar tu configuración en Kali Linux:

1. Modificar la configuración del servidor (Bind-Address)

Por defecto, MariaDB solo acepta conexiones desde 127.0.0.1. Debes cambiar esto para que acepte conexiones de la red:

  1. Abre el archivo de configuración:

    sudo nano /etc/mysql/mariadb.conf.d/50-server.cnf

  2. Busca la línea que dice: bind-address = 127.0.0.1

  3. Cámbiala por: bind-address = 0.0.0.0 (Esto significa "escuchar en todas las interfaces de red").

  4. Guarda y sal (Ctrl+O, Enter, Ctrl+X).

  5. Reinicia el servicio: sudo systemctl restart mariadb

2. Script de Bash Ajustado para Acceso Remoto

He modificado el script anterior para que el usuario que crees pueda conectarse desde cualquier IP ('%') y no solo desde localhost.

Bash
#!/bin/bash

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

# Verificar Root
if [ "$EUID" -ne 0 ]; then 
  echo -e "${ROJO}Error: Ejecuta con sudo.${NC}"
  exit 1
fi

echo -e "${VERDE}--- Configuración de DB con ACCESO REMOTO ---${NC}"

read -p "Nombre de la base de datos: " DB_NAME
read -p "Nombre del usuario: " DB_USER
read -s -p "Contraseña: " DB_PASS
echo -e "\n"

# El cambio clave aquí es el uso de '%' en lugar de 'localhost'
mysql -e "CREATE DATABASE IF NOT EXISTS \`${DB_NAME}\`;"
mysql -e "CREATE USER IF NOT EXISTS '${DB_USER}'@'%' IDENTIFIED BY '${DB_PASS}';"
mysql -e "GRANT ALL PRIVILEGES ON \`${DB_NAME}\`.* TO '${DB_USER}'@'%';"
mysql -e "FLUSH PRIVILEGES;"

if [ $? -eq 0 ]; then
    echo -e "${VERDE}✔ Configuración remota lista.${NC}"
    echo "Recuerda que bind-address debe estar en 0.0.0.0 en 50-server.cnf"
else
    echo -e "${ROJO}✘ Error en la ejecución.${NC}"
fi

Resumen Visual del Flujo de Conexión

Cuando intentas conectar desde fuera, la comunicación sigue este camino:

Tip de Kali: Si tienes el firewall ufw activo, no olvides abrir el puerto 3306 con: sudo ufw allow 3306/tcp.

 

Para verificar que todo ha quedado bien configurado, vamos a realizar una prueba de conexión rápida. Esto confirmará que tanto el usuario con permisos remotos como el bind-address están funcionando correctamente.

1. Prueba de conexión local (Verificar el usuario)

Primero, asegúrate de que el usuario puede entrar desde la misma máquina Kali, pero simulando una conexión de red:

Bash
mysql -u tu_usuario -p -h 127.0.0.1

(Si te pide la contraseña y entras al prompt MariaDB [(none)]>, el usuario está bien creado).

2. Prueba de conexión remota (Desde otra máquina)

Si tienes otra máquina en la misma red (o una máquina virtual), intenta conectar usando la IP de tu Kali:

  1. Obtén la IP de tu Kali: hostname -I (supongamos que es 192.168.1.50).

  2. Desde la otra máquina, ejecuta:

    Bash
    mysql -u tu_usuario -p -h 192.168.1.50

¿Qué pasa si no conecta? (Troubleshooting)

Si recibes un error de "Connection refused" o "Timeout", revisa estos tres puntos clave:

ProblemaSolución
Firewall bloqueandoEjecuta sudo ufw allow 3306/tcp para abrir el puerto.
Bind-address incorrectoVerifica en /etc/mysql/mariadb.conf.d/50-server.cnf que no diga 127.0.0.1.
Servicio caídoReinicia siempre tras cambios: sudo systemctl restart mariadb.

Un toque final para tu laboratorio

Como estás en Kali, es muy probable que quieras ver los logs en tiempo real para saber quién intenta conectar a tu base de datos (útil para monitorear ataques o pruebas).

 

Activar el General Log es como poner una cámara de seguridad en tu base de datos. En Kali Linux, esto es súper útil para ver en tiempo real si tus scripts están enviando las consultas correctas o si alguien está intentando un ataque de SQL Injection.

Sigue estos pasos para activarlo y visualizarlo:

1. Activar el Log desde la Consola de MariaDB

No necesitas reiniciar el servidor para esto. Entra a MariaDB y ejecuta:

SQL
SET GLOBAL general_log = 'ON';
SET GLOBAL log_output = 'FILE';
SET GLOBAL general_log_file = '/var/log/mysql/query.log';

2. Dar permisos al archivo de Log

Para que el sistema pueda escribir y tú puedas leer el archivo sin problemas de permisos:

Bash
sudo touch /var/log/mysql/query.log
sudo chown mysql:adm /var/log/mysql/query.log
sudo chmod 640 /var/log/mysql/query.log

3. ¡La magia! Ver las consultas en tiempo real

Ahora, abre una nueva terminal y usa el comando tail con el parámetro -f (follow). Esto dejará la terminal abierta "escuchando" cada movimiento de la base de datos:

Bash
sudo tail -f /var/log/mysql/query.log

¿Qué verás en esa pantalla?

  • Cada vez que un usuario se conecte o desconecte.

  • Cualquier SELECT, INSERT o UPDATE que se ejecute.

  • Intentos fallidos de acceso.

Una advertencia importante (Performance)

El General Log registra absolutamente todo. Si dejas esto encendido en un servidor con mucho tráfico, el archivo de texto crecerá gigabytes en muy poco tiempo y podría ralentizar el disco.

Tip: Cuando termines tus pruebas, apágalo con:

SET GLOBAL general_log = 'OFF'; desde la consola de MariaDB.

Próximo paso: Seguridad

Esta es la mejor forma de proteger tu base de datos en un entorno de red. Si dejas el puerto 3306 abierto para todo el mundo (0.0.0.0), cualquier persona en tu red (o en internet, si tu IP es pública) podría intentar ataques de fuerza bruta contra tu usuario.

En Kali Linux, lo más sencillo es usar UFW (Uncomplicated Firewall). Vamos a configurar una regla que diga: "Solo permite tráfico al puerto 3306 si viene de ESTA dirección IP específica".

1. Instalar y activar UFW (si no lo tienes)

Bash
sudo apt update && sudo apt install ufw -y
sudo ufw default deny incoming
sudo ufw default allow outgoing

2. Crear la regla de acceso selectivo

Supongamos que la IP de tu otra máquina (desde donde te conectas) es 192.168.1.15. Ejecuta:

Bash
sudo ufw allow from 192.168.1.15 to any port 3306 proto tcp

3. Activar el firewall

Bash
sudo ufw enable

¿Cómo funciona esto?

El firewall actúa como un filtro antes de que el tráfico llegue siquiera a MariaDB. Aquí tienes el esquema de lo que acabamos de construir:

Verificación de reglas

Para ver qué reglas tienes activas y asegurarte de que no hay puertas abiertas innecesarias, usa:

Bash
sudo ufw status numbered

  • Si necesitas borrar una regla: sudo ufw delete [número_de_regla]

  • Si necesitas añadir otra IP: Repite el paso 2 con la nueva dirección.

Un último consejo de "Pentester"

Como estás usando Kali, es probable que quieras probar si tu seguridad funciona. Intenta conectar desde una tercera IP (una que no hayas autorizado). Deberías recibir un error de "Timeout", lo que significa que el firewall está descartando los paquetes silenciosamente (lo cual es genial, porque ni siquiera confirma que el puerto existe).

 

Cuando trabajas en Kali Linux, es común realizar pruebas, mover configuraciones y llenar logs. Tener un script de "limpieza profunda" (o cleanup) te permite dejar el sistema como nuevo y no dejar rastros de tus experimentos.

Aquí tienes un script que revierte los cambios de seguridad, limpia los registros de la base de datos y detiene los servicios si ya no los necesitas.

Script de Limpieza (limpiar_lab.sh)

Bash
#!/bin/bash

# Colores
AMARILLO='\033[1;33m'
NC='\033[0m'

echo -e "${AMARILLO}--- Iniciando limpieza del laboratorio de DB ---${NC}"

# 1. Desactivar el General Log en MariaDB
echo "Desactivando logs de consultas..."
sudo mysql -e "SET GLOBAL general_log = 'OFF';"

# 2. Vaciar el archivo de log (sin borrarlo para no romper permisos)
echo "Vaciando /var/log/mysql/query.log..."
sudo truncate -s 0 /var/log/mysql/query.log

# 3. Resetear reglas de Firewall (UFW)
# CUIDADO: Esto borra TODAS las reglas. Si tienes otras, hazlo manual.
read -p "¿Deseas resetear el firewall UFW por completo? (s/n): " confirm
if [ "$confirm" = "s" ]; then
    sudo ufw reset
    sudo ufw disable
    echo "Firewall reseteado y desactivado."
fi

# 4. Detener el servicio MariaDB (opcional)
read -p "¿Deseas detener el servicio de MariaDB? (s/n): " stop_service
if [ "$stop_service" = "s" ]; then
    sudo systemctl stop mariadb
    echo "Servicio detenido."
fi

echo -e "${AMARILLO}✔ Limpieza completada.${NC}"

¿Por qué es útil este script?

  • Truncate vs RM: Usamos truncate -s 0 en lugar de rm. Si borras el archivo, MariaDB podría dejar de escribir logs porque el "puntero" al archivo se rompe. Truncate simplemente lo deja en 0 bytes.

  • Privacidad: Si estás haciendo auditorías o CTFs (Capture The Flag), no querrás que tus propias consultas SQL queden guardadas en el historial del sistema.

  • Gestión de recursos: Detener MariaDB cuando no se usa libera memoria RAM, algo vital si corres Kali en una máquina virtual con pocos recursos.

Resumen de tu entorno actual

Ahora tienes un flujo completo:

  1. Instalación con mysql-defaults.

  2. Configuración en español y acceso remoto.

  3. Automatización con scripts de creación de usuarios/DB.

  4. Monitoreo con General Logs.

  5. Seguridad con UFW.

  6. Limpieza con el script final.

 

Hacer un backup (también llamado dump o volcado) es la regla de oro antes de realizar cualquier limpieza o cambio estructural. En Kali, la herramienta estándar es mariadb-dump (antiguamente mysqldump).

Aquí tienes cómo hacerlo de forma manual y cómo integrarlo en un script para que sea automático.

1. El comando manual

Para exportar toda una base de datos a un archivo .sql:

Bash
sudo mariadb-dump -u root -p nombre_de_tu_db > backup_mi_db.sql

Si quieres respaldar todas las bases de datos del servidor a la vez:

Bash
sudo mariadb-dump -u root -p --all-databases > backup_completo.sql

2. Script de Backup Automático (respaldo.sh)

Este script es ideal porque le añade la fecha y hora al nombre del archivo, evitando que un backup nuevo borre el anterior.

Bash
#!/bin/bash

# Configuración
USER="root"
DB_NAME="mi_laboratorio"
DESTINO="./backups"
FECHA=$(date +"%Y-%m-%d_%H-%M")

# Crear carpeta si no existe
mkdir -p $DESTINO

echo "Generando backup de: $DB_NAME..."

# Ejecutar el volcado
sudo mariadb-dump -u $USER $DB_NAME > $DESTINO/backup_${DB_NAME}_${FECHA}.sql

if [ $? -eq 0 ]; then
    echo -e "\033[0;32m✔ Backup guardado en: $DESTINO/backup_${DB_NAME}_${FECHA}.sql\033[0m"
else
    echo -e "\033[0;31m✘ Error al crear el backup\033[0m"
fi

3. Cómo restaurar (El proceso inverso)

Si algo sale mal y necesitas recuperar tus datos, el proceso es muy sencillo. Primero asegúrate de que la base de datos existe (si no, créala vacía) y luego ejecuta:

Bash
sudo mysql -u root -p nombre_de_tu_db < backup_mi_db.sql

Resumen de comandos de mantenimiento

TareaComando
Exportar DBmariadb-dump -u [user] -p [db] > file.sql
Importar DBmysql -u [user] -p [db] < file.sql
Ver tamaño de DBdu -h /var/lib/mysql (requiere sudo)

Con esto ya tienes un ciclo de vida completo para tus bases de datos en Kali: desde la creación y seguridad hasta el respaldo y la limpieza final.

 

 

Crear un entorno vulnerable (un "honeypot" o laboratorio de pruebas) es la mejor manera de entender cómo ocurren las brechas de seguridad.

Para que esto funcione, instalaremos un servidor web rápido y crearemos un archivo PHP que conecte con la base de datos que configuramos antes.

1. Preparar el servidor web

En tu Kali Linux, instala Apache y PHP:

Bash
sudo apt update
sudo apt install apache2 php php-mysql -y
sudo systemctl start apache2

2. Crear la aplicación vulnerable (index.php)

Vamos a crear un archivo en el directorio raíz del servidor web. Este código es intencionalmente inseguro porque inserta la variable $id directamente en la consulta SQL sin sanitizar.

  1. Borra el archivo por defecto: sudo rm /var/www/html/index.html

  2. Crea el nuevo archivo: sudo nano /var/www/html/index.php

  3. Pega el siguiente código:

PHP
<?php
$conexion = mysqli_connect("localhost", "pentester", "PasswordSegura123!", "mi_laboratorio");

$id = $_GET['id']; // ¡VULNERABLE! No hay filtro.

$query = "SELECT usuario, email FROM usuarios WHERE id = $id";
$resultado = mysqli_query($conexion, $query);

while ($fila = mysqli_fetch_assoc($resultado)) {
    echo "<h1> Perfil de: " . $fila['usuario'] . "</h1>";
    echo "Email: " . $fila['email'];
}
?>

3. Insertar datos de prueba

Para que SQLmap tenga algo que "robar", necesitamos datos en la tabla. Entra a MariaDB y ejecuta:

SQL
USE mi_laboratorio;
CREATE TABLE usuarios (id INT, usuario VARCHAR(50), email VARCHAR(50));
INSERT INTO usuarios VALUES (1, 'admin', 'admin@local.test'), (2, 'victima', 'user@test.com');

4. ¡A probar con SQLmap!

Ahora que tu web está corriendo en http://localhost/index.php?id=1, abre una terminal y lanza el ataque:

Bash
sqlmap -u "http://localhost/index.php?id=1" --banner --current-db

¿Qué está pasando aquí?

SQLmap detectará que el parámetro id es vulnerable. Si le pides --dump, verás cómo extrae toda tu tabla de usuarios en segundos.

Visualización en vivo: Si tienes abierta la terminal con el comando tail -f /var/log/mysql/query.log que configuramos antes, verás cientos de consultas extrañas entrando de golpe. ¡Eso es SQLmap trabajando!

 

Pasar de un código vulnerable a uno seguro es el paso más importante para cualquier desarrollador o administrador de sistemas. La técnica que vamos a usar se llama Consultas Preparadas (Prepared Statements).

¿Por qué el código anterior era peligroso?

En el código anterior, hacíamos una concatenación: "SELECT ... WHERE id = " . $id.

Si un atacante enviaba 1 OR 1=1, la consulta se convertía en "SELECT ... WHERE id = 1 OR 1=1", lo que devolvía todos los registros de la tabla.

El Código Seguro (index_seguro.php)

Modifica tu archivo PHP con esta estructura profesional y segura:

PHP
<?php
// 1. Conexión a la base de datos
$conexion = new mysqli("localhost", "pentester", "PasswordSegura123!", "mi_laboratorio");

// 2. Obtener el ID del parámetro GET
$id_usuario = $_GET['id'];

// 3. PREPARAR la consulta con un marcador de posición (?)
// Esto le dice a MySQL: "Espera un dato, pero no lo ejecutes todavía"
$stmt = $conexion->prepare("SELECT usuario, email FROM usuarios WHERE id = ?");

// 4. VINCULAR el parámetro (s = string, i = integer)
// Aquí "i" indica que el ID debe ser un número entero. Si mandan texto, fallará.
$stmt->bind_param("i", $id_usuario);

// 5. EJECUTAR y obtener resultados
$stmt->execute();
$resultado = $stmt->get_result();

if ($fila = $resultado->fetch_assoc()) {
    echo "<h1> Perfil de: " . htmlspecialchars($fila['usuario']) . "</h1>";
    echo "Email: " . htmlspecialchars($fila['email']);
} else {
    echo "Usuario no encontrado.";
}

$stmt->close();
$conexion->close();
?>

¿Qué hace que esto sea "Hack-Proof"?

  1. Separación de Datos y Lógica: Al usar el signo ?, la base de datos compila la estructura de la consulta antes de recibir los datos del usuario. El dato se trata puramente como texto o número, nunca como parte del comando SQL.

  2. Tipado Estricto: Con bind_param("i", ...), si alguien intenta inyectar código (como '1 OR 1=1'), el sistema intentará convertirlo a un número entero y, al fallar o no coincidir, la inyección simplemente no se ejecutará.

  3. Protección XSS: He añadido htmlspecialchars(). Esto evita que, si un atacante logra meter código JavaScript en tu base de datos, este se ejecute en el navegador de otros usuarios.

Prueba final con SQLmap

Si intentas ejecutar SQLmap contra esta nueva versión:

Bash
sqlmap -u "http://localhost/index_seguro.php?id=1"

Verás que SQLmap te dirá algo como: "Target parameter 'id' does not seem to be injectable". ¡Misión cumplida!

Resumen de tu Aprendizaje

Has recorrido todo el camino:

  • Instalaste y configuraste el entorno en Kali.

  • Automatizaste la creación de DBs y Backups.

  • Abriste el acceso remoto y lo protegiste con un Firewall.

  • Creaste una vulnerabilidad, la explotaste y luego la parcheaste.

 Este es el toque final para tu laboratorio en Kali. Un script de auditoría (o hardening check) es una herramienta que escanea tu propia base de datos en busca de configuraciones débiles que un atacante podría aprovechar.

En lugar de atacar desde fuera con SQLmap, este script mira "dentro" de las tablas del sistema de MariaDB.

Script de Auditoría de Seguridad (auditoria_db.sh)

Bash
#!/bin/bash

# Colores para el reporte
ROJO='\033[0;31m'
VERDE='\033[0;32m'
AMARILLO='\033[1;33m'
NC='\033[0m'

echo -e "${AMARILLO}--- Iniciando Auditoría de Seguridad MariaDB ---${NC}\n"

# 1. Verificar usuarios sin contraseña
echo -n "1. Usuarios sin contraseña: "
users_no_pass=$(sudo mysql -N -s -e "SELECT COUNT(*) FROM mysql.user WHERE password='' OR authentication_string='';")
if [ "$users_no_pass" -gt 0 ]; then
    echo -e "${ROJO}PELIGRO ($users_no_pass usuarios encontrados)${NC}"
else
    echo -e "${VERDE}OK${NC}"
fi

# 2. Verificar si root puede conectar remotamente
echo -n "2. Root con acceso remoto (%): "
root_remote=$(sudo mysql -N -s -e "SELECT COUNT(*) FROM mysql.user WHERE user='root' AND host='%';")
if [ "$root_remote" -gt 0 ]; then
    echo -e "${ROJO}ALTO RIESGO (Detectado)${NC}"
else
    echo -e "${VERDE}SEGURO (Solo local)${NC}"
fi

# 3. Verificar bases de datos de prueba (test)
echo -n "3. Existencia de base de datos 'test': "
test_db=$(sudo mysql -N -s -e "SHOW DATABASES LIKE 'test';")
if [ ! -z "$test_db" ]; then
    echo -e "${AMARILLO}ADVERTENCIA (Eliminar DB 'test')${NC}"
else
    echo -e "${VERDE}OK${NC}"
fi

# 4. Verificar carga de archivos locales (LOAD DATA LOCAL INFILE)
echo -n "4. Local Infile (Lectura de archivos): "
infile_status=$(sudo mysql -N -s -e "SHOW VARIABLES LIKE 'local_infile';" | awk '{print $2}')
if [ "$infile_status" == "ON" ]; then
    echo -e "${AMARILLO}ACTIVADO (Riesgo de exfiltración)${NC}"
else
    echo -e "${VERDE}DESACTIVADO (Seguro)${NC}"
fi

echo -e "\n${AMARILLO}--- Fin de la Auditoría ---${NC}"

¿Qué significan estos puntos?

  • Usuarios sin contraseña: Es la vulnerabilidad más básica. A veces, al instalar mysql-defaults, se crean usuarios de mantenimiento que quedan abiertos.

  • Root Remoto: El usuario root NUNCA debería poder conectar desde %. Si alguien adivina la clave de root remotamente, tiene el control total de tu servidor.

  • Base de datos 'test': Por defecto, MySQL trae una base de datos llamada test a la que cualquiera puede entrar. Borrarla es parte del proceso de "limpieza" estándar.

  • Local Infile: Si está en ON, un atacante con acceso SQL podría usar comandos para leer archivos sensibles de tu Kali (como /etc/passwd) y verlos en los resultados de una consulta.

El "Checkmate" de la Seguridad

Si el script de auditoría te da muchos errores en rojo, la forma más rápida de solucionar casi todo de golpe es el comando oficial que mencionamos al principio:

Bash
sudo mysql_secure_installation

Este asistente interactivo te guiará para poner clave a root, borrar usuarios anónimos y eliminar la base de datos de prueba.

Resumen del flujo de trabajo en Kali

PasoHerramienta/Concepto
Configuraciónmysql-defaults + scripts de Bash
DefensaUFW (Firewall) + Prepared Statements (PHP)
OfensivaSQLmap (para pruebas de penetración)
ControlGeneral Log + Auditoría Script

Tener una documentación clara es lo que separa a un usuario casual de un profesional de la ciberseguridad o un administrador de sistemas. He preparado este archivo en formato Markdown (.md) que resume todo nuestro trabajo.

Puedes copiar este contenido en un archivo llamado GUIA_MYSQL_KALI.md en tu carpeta de notas.

📚 Guía Maestra: MySQL/MariaDB en Kali Linux

Esta guía resume la configuración, seguridad, explotación controlada y defensa de un entorno de base de datos.

1. Configuración Inicial

El paquete mysql-defaults en Kali apunta a MariaDB.

  • Instalación: sudo apt install default-mysql-server

  • Idioma (Español): Editar /etc/mysql/mariadb.conf.d/50-server.cnf y añadir:

    • lc-messages-dir = /usr/share/mysql

    • lc-messages = es_ES

2. Acceso Remoto y Seguridad de Red

Para permitir conexiones externas de forma segura:

  1. Escucha Global: Cambiar bind-address = 127.0.0.1 a 0.0.0.0 en el archivo .cnf.

  2. Firewall (UFW): Restringir el puerto 3306 a una IP específica:

    sudo ufw allow from [TU_IP] to any port 3306 proto tcp

3. Scripts de Automatización (Resumen)

A. Creación de DB y Usuario

Bash
mysql -e "CREATE DATABASE IF NOT EXISTS lab_db;"
mysql -e "CREATE USER 'user'@'%' IDENTIFIED BY 'pass';"
mysql -e "GRANT ALL PRIVILEGES ON lab_db.* TO 'user'@'%';"

B. Respaldo (Backup)

Bash
mariadb-dump -u root -p lab_db > backup_$(date +%F).sql

4. Auditoría y Pentesting

Para probar la seguridad de tus aplicaciones, usamos un flujo de Ataque vs Defensa:

FaseAcción / HerramientaPropósito
VulnerabilidadParámetro $_GET['id'] sin filtrarSimular un punto de entrada débil.
Ataquesqlmap -u "URL" --dbsAutomatizar la extracción de datos.
Monitoreotail -f /var/log/mysql/query.logVer las huellas del atacante en tiempo real.
DefensaPrepared Statements (PHP)Prevenir la inyección separando lógica de datos.

5. Comandos de Supervivencia

  • Reiniciar servicio: sudo systemctl restart mariadb

  • Ver logs en vivo: SET GLOBAL general_log = 'ON'; (dentro de MySQL).

  • Hardening rápido: sudo mysql_secure_installation

¡Esa es la actitud de un verdadero usuario de Kali! La línea de comandos (CLI) te da un control total, es más rápida y consume menos recursos que cualquier interfaz gráfica.

Para profundizar, vamos a ver técnicas avanzadas de administración interna y análisis forense de la base de datos que te harán moverte como un experto.

1. Consultas de "Inteligencia" (Information Schema)

En lugar de solo ver tablas, puedes interrogar al diccionario de datos de MariaDB para encontrar debilidades o estructuras. Esto es lo que herramientas como SQLmap hacen por debajo.

Entra a MariaDB (sudo mysql) y prueba esto:

  • Listar tablas con más filas (útil para encontrar datos sensibles):

    SQL
    SELECT table_name, table_rows FROM information_schema.tables 
WHERE table_schema = 'mi_laboratorio' ORDER BY table_rows DESC;

  • Buscar columnas que se llamen "pass" o "pwd" en todo el servidor:

    SQL
    SELECT table_schema, table_name, column_name FROM information_schema.columns 
WHERE column_name LIKE '%pass%' OR column_name LIKE '%pwd%';

2. Gestión de Procesos en Tiempo Real

Si sospechas que un script se ha quedado colgado o que alguien está ejecutando una consulta pesada, puedes ver qué está pasando "ahora mismo":

  • Ver procesos activos:

    SQL
    SHOW FULL PROCESSLIST;

  • Matar un proceso sospechoso:

    Si ves un ID (por ejemplo, el 45) que está tardando demasiado:

    SQL
    KILL 45;

3. Comandos de Terminal (Fuera de MySQL)

No siempre necesitas entrar al prompt de MySQL. Puedes administrar desde la Bash de Kali:

  • Verificar la versión y variables sin entrar:

    mysqladmin -u root -p variables | grep version

  • Comprobar si el servidor "está vivo":

    mysqladmin -u root -p ping

  • Monitor de rendimiento rápido:

    mysqladmin -u root -p proc stat

4. Análisis de fragmentación y optimización

Con el tiempo, las tablas de laboratorio pueden volverse lentas tras borrar y meter datos. Puedes optimizarlas directamente desde la terminal:

Bash
# Optimizar todas las tablas de una base de datos específica
mysqlcheck -u root -p --optimize mi_laboratorio

5. El "History" de MySQL

Al igual que en Bash, MySQL guarda un historial de lo que escribes. En Kali, esto es un riesgo de seguridad si dejas contraseñas en los comandos.

  • Dónde está: ~/.mysql_history

  • Limpiarlo: cat /dev/null > ~/.mysql_history

  • Evitar que guarde historial (truco ninja):

    Crea un enlace simbólico a /dev/null:

    ln -sf /dev/null ~/.mysql_history

¡Esta es una excelente manera de combinar tus habilidades de Bash con la administración de bases de datos! Vamos a crear un script que no solo recoja datos técnicos, sino que los formatee en un archivo HTML visual que podrías abrir en el navegador de tu Kali (Firefox) para ver un reporte profesional.

Este script usará etiquetas HTML básicas y comandos de consola para extraer la "salud" de MariaDB.

Script: Generador de Reporte de Salud (reporte_db.sh)

Bash
#!/bin/bash

# Configuración
OUTPUT="reporte_mariadb.html"
FECHA=$(date +"%d/%m/%Y %H:%M:%S")

echo "Generando reporte de salud..."

# Inicio del HTML
cat <<EOF > $OUTPUT
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Reporte de Salud MariaDB - Kali Linux</title>
    <style>
        body { font-family: sans-serif; background: #2c3e50; color: #ecf0f1; padding: 20px; }
        h1 { color: #3498db; }
        .card { background: #34495e; padding: 15px; border-radius: 8px; margin-bottom: 20px; box-shadow: 0 4px 6px rgba(0,0,0,0.3); }
        table { width: 100%; border-collapse: collapse; }
        th, td { text-align: left; padding: 10px; border-bottom: 1px solid #7f8c8d; }
        th { background: #2980b9; }
        .status-ok { color: #2ecc71; font-weight: bold; }
    </style>
</head>
<body>
    <h1>📊 Reporte de Estado MariaDB</h1>
    <p>Generado el: $FECHA</p>

    <div class="card">
        <h2>1. Información del Servidor</h2>
        <table>
            <tr><th>Variable</th><th>Valor</th></tr>
            $(mysql -N -s -e "SHOW VARIABLES WHERE Variable_name IN ('version', 'hostname', 'datadir', 'max_connections');" | awk '{print "<tr><td>" $1 "</td><td>" $2 "</td></tr>"}')
        </table>
    </div>

    <div class="card">
        <h2>2. Tamaño de las Bases de Datos</h2>
        <table>
            <tr><th>Base de Datos</th><th>Tamaño (MB)</th></tr>
            $(mysql -N -s -e "SELECT table_schema 'DB', ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) 'Size' FROM information_schema.tables GROUP BY table_schema;" | awk '{print "<tr><td>" $1 "</td><td>" $2 "</td></tr>"}')
        </table>
    </div>

    <div class="card">
        <h2>3. Usuarios y Permisos Críticos</h2>
        <table>
            <tr><th>Usuario</th><th>Host</th><th>¿Acceso Total?</th></tr>
            $(mysql -N -s -e "SELECT user, host, Super_priv FROM mysql.user WHERE Super_priv='Y';" | awk '{print "<tr><td>" $1 "</td><td>" $2 "</td><td>" $3 "</td></tr>"}')
        </table>
    </div>

    <p><em>Reporte generado automáticamente desde Kali Linux CLI.</em></p>
</body>
</html>
EOF

echo -e "\033[0;32m✔ Reporte generado con éxito: $OUTPUT\033[0m"
# Abrir automáticamente en Firefox (opcional)
# firefox $OUTPUT &

¿Cómo funciona este "Reporteador"?

  1. Heredoc (cat <<EOF): Es una técnica de Bash que permite escribir bloques grandes de texto (en este caso HTML/CSS) directamente en un archivo, inyectando variables en medio.

  2. Inyección de Comandos: Dentro del HTML, ejecutamos sub-shells $(mysql ...) que obtienen los datos reales de MariaDB y los formatean como filas de tabla (<tr><td>).

  3. Information Schema: Usamos las tablas internas de MySQL para calcular el tamaño de los datos en disco, algo que no se ve con un simple SHOW DATABASES.

Análisis de los resultados

Cuando abras el archivo reporte_mariadb.html en Firefox, fíjate especialmente en la sección de Usuarios y Permisos Críticos:

  • Si ves muchos usuarios con Super_priv='Y', tu superficie de ataque es grande.

  • Si el tamaño de datadir está cerca del límite de tu disco en Kali, podrías tener problemas de rendimiento pronto.

¿Qué te gustaría hacer ahora?

Podríamos llevar esto al siguiente nivel:

  1. Programar el reporte: Hacer que se ejecute solo cada hora usando cron.

  2. Análisis de Índices: Añadir una sección al reporte que te diga qué tablas no tienen índices (lo que las hace lentas).

  3. Logs de Errores: Incluir las últimas 10 líneas del log de errores de MariaDB en el HTML.

Location: España

Entradas populares de este blog

Hacking y ciberseguridad en kali linux con Fping

Imagen
  www.onlinetis.com   Hacking y ciberseguridad en kali linux con Fping Fping es un programa similar a ping que utiliza la solicitud de eco del Protocolo de Mensajes de Control de Internet (ICMP) para determinar si un host objetivo responde. fping se diferencia de ping en que permite especificar cualquier número de objetivos en la línea de comandos o un archivo con las listas de objetivos a los que se hará ping. En lugar de enviar a un objetivo hasta que se agote el tiempo de espera o responda, fping envía un paquete de ping y pasa al siguiente objetivo mediante un sistema de turnos rotatorios. Como instalar:  sudo apt install fping fping Enviar paquetes ICMP ECHO_REQUEST a los hosts de la red   fping6 Compatibilidad con versiones anteriores de fping anteriores a la versión 4.0 El comando fping en Kali Linux es una utilidad de red que se utiliza para enviar paquetes de ICMP (Protocolo de mensajes de control de Internet) a varios hosts de forma simultánea. A diferen...
LEER MAS »

Hacking y ciberseguridad en kali linux con atk6-thcping6

Imagen
www.onlinetis.com Hacking y ciberseguridad en kali linux con atk6-thcping6 Parece que estás interesado en usar atk6-thcping6 en Kali Linux. Esta herramienta es parte del conjunto de utilidades thc-ipv6 , diseñado para probar las debilidades del protocolo IPv6. Para usar atk6-thcping6 , primero necesitas tener instalado el paquete thc-ipv6 . En la mayoría de las distribuciones de Kali, ya viene preinstalado, pero si no, puedes instalarlo con el siguiente comando: Bash sudo apt install thc-ipv6 Una vez que lo tienes instalado, la sintaxis básica para atk6-thcping6 es: Bash atk6-thcping6 <interface> <target> [opciones] Aquí está el desglose de los argumentos y opciones más comunes: <interface> : La interfaz de red que usarás para enviar el paquete. Por ejemplo, eth0 , wlan0 , etc. <target> : La dirección IPv6 del objetivo al que quieres hacer ping. [opciones] : Puedes usar varias opciones para modificar el comportamiento del ping. La mejor manera de ver todas la...
LEER MAS »

Como utilizar Fierce en kali linux

Imagen
  www.onlinetis.com   Como utilizar Fierce en kali linux Fierce es un escáner semiligero que ayuda a localizar direcciones IP no contiguas y nombres de host en dominios específicos. Está pensado como precursor de nmap, unicornscan, nessus, nikto, etc., ya que todos ellos requieren que se conozca previamente el espacio IP buscado. No realiza exploits ni escanea internet indiscriminadamente. Está diseñado específicamente para localizar objetivos probables tanto dentro como fuera de una red corporativa. Dado que utiliza principalmente DNS, es frecuente encontrar redes mal configuradas que filtran el espacio de direcciones interno. Esto es especialmente útil en malware dirigido. Originalmente escrito por RSnake y otros en http://ha.ckers.org/. Se trata simplemente de una conversión a Python 3 para simplificar y modernizar el código base. Como instalar: sudo apt install fierce Escáner DNS que ayuda a localizar espacios de IP no contiguos y nombres de host contra dominios específico...
LEER MAS »