Hacking ético en Linux: cómo detectar archivos sospechosos y rastrear cambios en tu servidor

Análisis forense básico desde la terminal con find, mtime, ctime y otras herramientas de Linux.

Imagina que llegas una mañana, te conectas por SSH a tu servidor Linux y encuentras algo extraño. Quizás un servicio está consumiendo más CPU de lo habitual, ha aparecido un proceso que no reconoces o simplemente tienes la sospecha de que alguien ha estado haciendo cosas que no debería.

Lo primero que solemos hacer muchos administradores es comprobar los procesos, revisar los logs y echar un vistazo al sistema de archivos.

Pero hay una pregunta que me parece especialmente interesante:

¿Cómo puedo saber qué archivos se han modificado en mi servidor durante las últimas 24 horas?

Y todavía más interesante: ¿qué ocurre si alguien ha cambiado los permisos de un archivo sin modificar su contenido?

Para responder a estas preguntas no necesitamos instalar herramientas complejas ni desplegar una plataforma de seguridad. Linux ya incorpora utilidades que nos permiten realizar una primera investigación.

En este artículo voy a utilizar find, mtime, ctime, grep y algunos comandos adicionales para realizar una pequeña auditoría forense desde la terminal.

Eso sí, conviene aclarar una cosa desde el principio: encontrar archivos modificados recientemente no significa que nuestro servidor haya sido comprometido. Lo que estamos haciendo es buscar indicios que merezcan una investigación.

1. El primer error: confiar únicamente en ls -a

Cuando queremos ver qué archivos hay en un directorio, normalmente utilizamos:

ls -la

Este comando muestra archivos normales y ocultos, permisos, propietario, tamaño y fecha de modificación.

Por ejemplo:

-rw-r--r-- 1 root root  1240 oct 18 10:30 config.conf
-rwxr-xr-x 1 root root   840 oct 19 02:15 backup.sh
-rw------- 1 root root   320 oct 19 03:20 .cache_data

El archivo .cache_data podría llamar nuestra atención porque está oculto, pero eso no significa que sea malicioso. Linux utiliza constantemente archivos y directorios que comienzan por un punto.

El problema de ls es que nos muestra únicamente el contenido del directorio que estamos consultando, salvo que utilicemos opciones recursivas.

Además, la fecha que normalmente vemos corresponde a la modificación de los datos del archivo, no necesariamente a otros cambios en sus metadatos.

Un atacante podría modificar los permisos de un script sin alterar su contenido, y esa operación no quedaría reflejada en la fecha de modificación que muestra ls -l.

Por eso, cuando necesito investigar qué ha ocurrido en un sistema, prefiero comenzar con find.

2. Buscar archivos modificados durante las últimas 24 horas con mtime

Linux mantiene diferentes marcas de tiempo asociadas a sus archivos.

Una de ellas es mtime, abreviatura de Modification Time.

Esta marca registra cuándo se modificaron por última vez los datos de un archivo.

Podemos utilizarla para localizar archivos modificados recientemente.

sudo find / -type f -mtime -1 2>/dev/null

Vamos a entender el comando:

sudo: permite consultar archivos y directorios protegidos.
find /: inicia la búsqueda desde la raíz del sistema.
-type f: limita los resultados a archivos regulares.
-mtime -1: busca archivos modificados hace menos de 24 horas.
2>/dev/null: oculta los mensajes de error, como los de permisos denegados.

Una posible salida sería:

/etc/ssh/sshd_config
/var/log/auth.log
/tmp/update.sh
/home/admin/.bash_history
/usr/local/bin/maintenance.sh

Ahora tenemos información interesante.

Que aparezca /var/log/auth.log puede ser completamente normal, porque los logs se actualizan constantemente.

Pero encontrar modificaciones inesperadas en /etc/ssh/sshd_config o descubrir un script desconocido en /tmp merece una revisión.

No porque sean pruebas de un ataque, sino porque esos cambios podrían tener consecuencias sobre la seguridad.

¿Qué significa exactamente -mtime -1?

Este detalle suele provocar confusiones.

Con GNU find, los intervalos de mtime se expresan en días de 24 horas. Los ejemplos habituales serían:

Parámetro	Significado
`-mtime 0`	Modificado hace menos de 24 horas
`-mtime 1`	Modificado entre 24 y 48 horas atrás
`-mtime -1`	Modificado hace menos de 24 horas
`-mtime +1`	Modificado hace al menos 48 horas

En este caso, -mtime 0 y -mtime -1 nos sirven para buscar modificaciones de las últimas 24 horas.

Si queremos trabajar con minutos, también podemos utilizar mmin.

Por ejemplo, para buscar archivos modificados durante los últimos 30 minutos:

sudo find /etc -type f -mmin -30

Esto resulta especialmente útil cuando sabemos aproximadamente a qué hora ocurrió un incidente.

3. El dato que muchos olvidan: ctime

Aquí llegamos a una de las partes más interesantes.

Además de mtime, Linux mantiene otra marca de tiempo denominada ctime, que significa Change Time.

Y quiero aclarar algo porque es una confusión bastante habitual:

**ctime** no es la fecha de creación del archivo.

Representa el momento en el que cambió por última vez su estado o metadatos asociados al inodo.

Por ejemplo, puede actualizarse cuando:

Cambiamos sus permisos mediante chmod.
Modificamos su propietario con chown.
Alteramos el contenido del archivo.
Cambiamos determinados metadatos del sistema de archivos.

¿Por qué nos interesa desde el punto de vista de la seguridad?

Imaginemos que alguien consigue acceso a nuestro servidor y modifica los permisos de un script para permitir su ejecución.

Es posible que no cambie una sola línea del código, pero sí estará modificando uno de sus atributos.

Y ese cambio puede quedar reflejado en ctime.

Podemos localizar archivos cuyo estado haya cambiado durante las últimas 24 horas:

sudo find / -type f -ctime -1 2>/dev/null

O limitar la búsqueda a directorios especialmente relevantes:

sudo find /etc /usr/local/bin /opt \
  -type f -ctime -1 2>/dev/null

Esto permite reducir el número de resultados y concentrarnos en ubicaciones donde suelen almacenarse configuraciones, scripts y aplicaciones.

Hay otra diferencia interesante: un usuario con permisos suficientes puede modificar artificialmente el mtime mediante herramientas como touch, mientras que ctime no se establece directamente con ese comando.

No significa que sea imposible manipularlo en todos los escenarios. Un atacante con control privilegiado del sistema podría alterar evidencias, incluso a nivel del reloj del sistema o del almacenamiento.

Por eso nunca debemos interpretar una marca de tiempo como una prueba irrefutable.

4. Comprobar mtime y ctime con stat

Una de mis herramientas favoritas para investigar archivos concretos es stat.

Supongamos que encontramos este archivo:

/tmp/update.sh

Podemos examinar sus metadatos:

stat /tmp/update.sh

Una salida de ejemplo sería:

File: /tmp/update.sh
Size: 1536       Blocks: 8
Access: (0755/-rwxr-xr-x)
Uid: (0/root)
Gid: (0/root)

Access: 2026-10-19 08:30:00
Modify: 2026-10-15 12:00:00
Change: 2026-10-19 08:25:00
Birth:  2026-10-15 12:00:00

Fijémonos en estos dos valores:

Modify: 2026-10-15 12:00:00
Change: 2026-10-19 08:25:00

El contenido del archivo no se ha modificado desde el 15 de octubre, pero su estado cambió el día 19.

¿Qué ocurrió?

Podría tratarse de un cambio de permisos, de propietario o de alguna otra operación que haya modificado su estado.

También podría ser una operación administrativa perfectamente legítima.

No podemos saber exactamente qué sucedió únicamente observando ctime, pero ahora tenemos una pista y una hora aproximada para investigar.

El campo Birth, cuando está disponible, representa la fecha de creación registrada por el sistema de archivos. No todos los sistemas de archivos o entornos proporcionan ese dato.

5. Buscar archivos sospechosos en /tmp y otros directorios

Si tuviera que revisar rápidamente un servidor, uno de los primeros lugares donde miraría sería /tmp.

¿Por qué?

Porque es un directorio destinado a archivos temporales, generalmente escribible por múltiples usuarios. Eso lo convierte en una ubicación que también puede utilizarse para almacenar scripts o archivos no autorizados.

Podemos combinar find con grep para buscar archivos modificados recientemente:

sudo find / -type f -mtime -1 2>/dev/null \
  | grep '^/tmp/'

En este ejemplo, grep filtra las rutas que comienzan por /tmp/.

También podríamos comprobar los cambios de estado:

sudo find / -type f -ctime -1 2>/dev/null \
  | grep -E '^/(tmp|var/tmp|dev/shm)/'

Ahora buscamos resultados en tres ubicaciones:

/tmp: archivos temporales.
/var/tmp: archivos temporales que pueden conservarse durante más tiempo.
/dev/shm: espacio temporal normalmente basado en memoria compartida.

Estas ubicaciones pueden contener cientos de archivos legítimos. Lo interesante es identificar elementos inesperados, especialmente scripts ejecutables o binarios desconocidos.

Una forma más eficiente de hacerlo

Aunque la combinación de find y grep es útil para aprender a filtrar resultados, cuando conocemos los directorios que queremos examinar, prefiero pasárselos directamente a find.

sudo find /tmp /var/tmp /dev/shm \
  -type f -mtime -1 2>/dev/null

Con esto evitamos recorrer innecesariamente todo el sistema de archivos.

También podemos buscar archivos con cambios de estado recientes:

sudo find /tmp /var/tmp /dev/shm \
  -type f -ctime -1 2>/dev/null

Y si nos interesan los archivos ejecutables:

sudo find /tmp /var/tmp /dev/shm \
  -type f -executable 2>/dev/null

Hay que recordar que -executable evalúa si el usuario que ejecuta find puede ejecutar el archivo. No garantiza que el archivo sea malicioso ni detecta todos los scripts que podrían ejecutarse mediante un intérprete.

6. Laboratorio práctico: simulando cambios sospechosos

Vamos a hacer una pequeña prueba para entender el comportamiento de estas marcas de tiempo.

No necesitamos máquinas virtuales ni herramientas de pentesting. Podemos realizar el ejercicio en cualquier distribución Linux con GNU find.

Trabajaremos en un directorio aislado dentro de /tmp.

Paso 1. Preparar el laboratorio

mkdir -p /tmp/lab-forense

echo '#!/bin/bash' > /tmp/lab-forense/test.sh
echo 'echo "Prueba de laboratorio"' \
  >> /tmp/lab-forense/test.sh

chmod 644 /tmp/lab-forense/test.sh

Hemos creado un script sencillo que únicamente imprime un mensaje.

Comprobamos sus metadatos:

stat /tmp/lab-forense/test.sh

Al ser un archivo recién creado, tanto mtime como ctime tendrán valores recientes.

Paso 2. Modificar solamente los permisos

Ahora ejecutamos:

chmod 755 /tmp/lab-forense/test.sh

Y volvemos a consultar:

stat /tmp/lab-forense/test.sh

Observaremos que ctime se ha actualizado, porque hemos cambiado los permisos.

En cambio, mtime continúa registrando la última modificación de los datos del archivo.

Puede que las dos marcas de tiempo estén muy próximas porque acabamos de crear el script, así que vamos a hacer una prueba adicional.

Paso 3. Modificar artificialmente mtime

Ejecutamos:

touch -d '3 days ago' /tmp/lab-forense/test.sh

Este comando establece la fecha de modificación y acceso del archivo aproximadamente tres días atrás.

Consultamos de nuevo:

stat /tmp/lab-forense/test.sh

Ahora deberíamos observar que:

mtime indica una fecha de hace tres días.
ctime sigue mostrando un cambio reciente.

Vamos a comprobarlo con find.

find /tmp/lab-forense -type f -mtime -1

Nuestro archivo no debería aparecer, porque su fecha de modificación se ha establecido tres días atrás.

Probamos ahora con:

find /tmp/lab-forense -type f -ctime -1

Esta vez sí debería aparecer:

/tmp/lab-forense/test.sh

Acabamos de comprobar por qué ctime resulta tan interesante durante una investigación.

Aunque modifiquemos la fecha de los datos del archivo con touch, el sistema registra un cambio reciente en sus metadatos.

Para terminar, podemos eliminar el laboratorio:

rm -r /tmp/lab-forense

Esta prueba debe realizarse sobre archivos propios y en un entorno de laboratorio, nunca alterando evidencias de un incidente real.

7. Crear un informe de archivos modificados recientemente

Cuando investigamos un servidor con muchos archivos, mostrar únicamente las rutas puede quedarse corto.

Podemos utilizar -printf de GNU find para incluir la fecha de modificación, los permisos y el propietario.

sudo find /etc /usr/local/bin /opt \
  -type f -mtime -1 \
  -printf '%TY-%Tm-%Td %TH:%TM:%TS %m %u %p\n' \
  2>/dev/null

Una salida ilustrativa sería:

2026-10-19 08:20:15 644 root /etc/ssh/sshd_config
2026-10-19 08:32:10 755 root /usr/local/bin/backup.sh
2026-10-19 09:05:43 644 root /opt/app/config.yml

Así podemos identificar rápidamente cuándo se modificó cada archivo.

También podemos crear un listado ordenado por la fecha del último cambio de estado:

sudo find /etc /usr/local/bin /opt \
  -type f -ctime -1 \
  -printf '%C@ %CY-%Cm-%Cd %CH:%CM:%CS %p\n' \
  2>/dev/null | sort -n

En este ejemplo, %C@ proporciona el instante de cambio de estado en segundos desde la época Unix, lo que permite ordenar cronológicamente los resultados.

Si queremos guardar un informe para una auditoría de nuestro propio laboratorio:

sudo find /tmp /var/tmp /dev/shm \
  -type f -ctime -1 \
  -printf '%CY-%Cm-%Cd %CH:%CM:%CS %m %u %p\n' \
  2>/dev/null > ~/informe-cambios.txt

En una investigación real deberíamos documentar también los errores de acceso, el momento de la captura y el origen de los datos. Siempre que sea posible, las evidencias deben conservarse fuera del sistema investigado.

8. Investigar un archivo sospechoso sin ejecutarlo

Imaginemos que durante nuestra búsqueda aparece algo como:

/tmp/system-update.sh

El nombre podría parecer legítimo, pero no deberíamos fiarnos de él.

Antes de hacer nada, podemos revisar sus metadatos:

stat /tmp/system-update.sh

Comprobar qué tipo de archivo es:

file /tmp/system-update.sh

Y calcular su hash SHA-256:

sha256sum /tmp/system-update.sh

El hash nos sirve para identificar una versión concreta del archivo y comprobar posteriormente si ha cambiado.

También podemos revisar los permisos:

ls -l /tmp/system-update.sh

Y verificar quién es su propietario.

Lo que no haría es ejecutarlo para comprobar qué hace.

Si desconocemos su procedencia, ejecutar un script podría activar precisamente el comportamiento que estamos investigando.

Para un análisis más profundo conviene trabajar con una copia preservada en un entorno aislado y utilizar herramientas especializadas.

9. Relacionar los cambios con los logs del sistema

Hasta ahora hemos investigado archivos, pero una buena auditoría no termina ahí.

Supongamos que descubrimos que /etc/ssh/sshd_config cambió a las 03:15 de la madrugada.

La siguiente pregunta sería:

¿Quién tenía acceso al servidor en ese momento?

En una distribución que utiliza systemd podemos consultar:

sudo journalctl --since "24 hours ago"

Para concentrarnos en SSH:

sudo journalctl -u sshd --since "24 hours ago"

En Debian y derivados, donde el servicio suele denominarse ssh, podemos utilizar:

sudo journalctl -u ssh --since "24 hours ago"

Estos comandos permiten revisar eventos recientes si el sistema dispone de los registros correspondientes.

En función de la distribución y de su configuración, también podemos encontrar información de autenticación en archivos como:

/var/log/auth.log
/var/log/secure

El objetivo es relacionar los cambios detectados con conexiones, tareas programadas, actualizaciones o actividades administrativas.

Por ejemplo, si una modificación coincide con una actualización autorizada mediante Ansible, probablemente tengamos una explicación razonable.

En cambio, si coincide con un inicio de sesión desconocido, habrá que investigar más.

Hay que tener presente que los registros pueden ser incompletos o haber sido manipulados si el sistema está comprometido.

10. Qué hacer si realmente sospechamos de una intrusión

Hasta aquí hemos utilizado herramientas de consulta para buscar indicios.

Pero una investigación forense profesional exige algo más que ejecutar comandos.

Si sospecho seriamente que un servidor de producción ha sido comprometido, no empezaría borrando archivos, reiniciando servicios o instalando herramientas sin evaluar primero las consecuencias.

Estas serían mis prioridades:

Registrar la hora de la sospecha y documentar los indicios encontrados.
Preservar las evidencias siguiendo un procedimiento de respuesta a incidentes, incluyendo registros y datos volátiles cuando corresponda.
Contener el incidente de forma controlada, teniendo en cuenta el impacto sobre los servicios y la conservación de evidencias.
Investigar los archivos, procesos, conexiones y mecanismos de persistencia con herramientas confiables.
Determinar el alcance del compromiso y recuperar los servicios desde una base confiable.

Una advertencia adicional: los comandos utilizados en este artículo son útiles para una revisión inicial de un servidor administrado por nosotros, pero ejecutarlos sobre un sistema realmente comprometido puede modificar ciertas evidencias. En un incidente serio, la adquisición y el análisis deberían realizarse conforme a un procedimiento forense, preferiblemente mediante herramientas confiables y sobre copias preservadas.

Tampoco debemos olvidar que un atacante con privilegios elevados puede manipular marcas de tiempo, registros e incluso herramientas del propio sistema.

Por eso, la ausencia de resultados sospechosos en find no demuestra que el servidor esté limpio.

11. Mi pequeña chuleta para investigar cambios en Linux

Estos son los comandos que tendría a mano para una revisión inicial en un sistema Linux administrado y bajo mi control.

Archivos modificados durante las últimas 24 horas:

sudo find / -type f -mtime -1 2>/dev/null

Archivos cuyo estado ha cambiado durante las últimas 24 horas:

sudo find / -type f -ctime -1 2>/dev/null

Archivos modificados en los últimos 30 minutos:

sudo find /etc -type f -mmin -30

Cambios recientes en directorios temporales:

sudo find /tmp /var/tmp /dev/shm \
  -type f -ctime -1 2>/dev/null

Archivos ejecutables en directorios temporales:

sudo find /tmp /var/tmp /dev/shm \
  -type f -executable 2>/dev/null

Consultar metadatos de un archivo:

stat /ruta/al/archivo

Calcular su hash:

sha256sum /ruta/al/archivo

Consultar eventos recientes:

sudo journalctl --since "24 hours ago"

Conclusión

Después de años trabajando con sistemas Linux, una de las cosas que más valoro es disponer de herramientas sencillas para entender qué está ocurriendo antes de modificar nada.

find es un buen ejemplo.

Un comando que normalmente utilizamos para localizar archivos también puede ayudarnos a detectar cambios recientes, identificar comportamientos inesperados y orientar una investigación de seguridad.

La diferencia está en saber interpretar correctamente los resultados.

mtime nos indica cuándo cambiaron los datos de un archivo.

ctime nos permite detectar cuándo cambió su estado, incluidos determinados metadatos.

Y herramientas como stat, sha256sum o journalctl nos ayudan a reunir más información para entender lo ocurrido.

Nada de esto sustituye una investigación forense completa, pero sí proporciona una buena base para comenzar a investigar sin confundir una sospecha con una prueba.

Porque en seguridad Linux, tan importante como saber qué comando ejecutar es entender exactamente qué nos está diciendo.

Referencia del vídeo que inspira este artículo:

Análisis forense en Linux: find, mtime y ctime (YouTube Shorts)