Cómo detectar cambios no autorizados en los archivos de tu sitio web con PHP
Aprende a detectar cambios inesperados en los archivos PHP de tu sitio web utilizando un monitor de integridad de archivos ligero. Crea un escáner PHP práctico, compara instantáneas confiables y identifica archivos modificados, añadidos o eliminados sin Composer.
Cómo detectar cambios no autorizados en archivos de su sitio web con PHP
Imagine abrir su sitio web una mañana y descubrir que algo ha cambiado. Una página redirige a los visitantes, un archivo PHP contiene código desconocido o un plugin se comporta de manera diferente a pesar de no haber una actualización prevista.
¿Qué archivos cambiaron? Revisar cientos manualmente no es realista. El monitoreo de integridad de archivos (FIM) compara el sistema de archivos actual con una instantánea confiable. Este tutorial crea un pequeño escáner PHP para sitios personalizados, extensiones y alojamiento compartido, sin Composer ni una base de datos.
1. ¿Qué es el monitoreo de integridad de archivos?
Un monitor registra rutas y hashes criptográficos de archivos seleccionados, y luego los vuelve a comprobar. Informa archivos ADDED, MODIFIED y DELETED. Estas diferencias son pistas para investigar, no prueba de un ataque: los despliegues normales también cambian archivos.
Por ejemplo:
website/
├── index.php
├── includes/
│ ├── bootstrap.php
│ └── database.php
└── plugins/
└── payment/gateway.php
Un escaneo posterior podría informar:
MODIFIED includes/bootstrap.php
ADDED plugins/payment/debug-shell.php
DELETED includes/database.php
El requisito crucial es una línea base confiable. Si un sitio fue comprometido antes de la instantánea inicial, los archivos maliciosos podrían ya estar registrados como normales.
2. ¿Crear un escáner o usar una herramienta existente?
Antes de programar, revise su plataforma. En WordPress, WP-CLI verifica los archivos del núcleo contra las sumas de comprobación oficiales:
wp core verify-checksums
wp plugin verify-checksums --all
El comando para plugins cubre principalmente plugins alojados en el repositorio de WordPress.org; los plugins personalizados y comerciales requieren otra referencia. En Joomla, extensiones consolidadas como Akeeba Admin Tools ofrecen monitoreo de cambios en archivos. Las aplicaciones gestionadas con Git también pueden comparar los artefactos desplegados contra una versión aprobada.
| Situación | Punto de partida |
|---|---|
| Núcleo de WordPress y plugins del repositorio | Verificación de sumas de comprobación con WP-CLI |
| Joomla con necesidades de seguridad continuas | Extensión de seguridad consolidada |
| Sitio PHP personalizado o extensiones personalizadas | Escáner de integridad PHP pequeño |
| Varios servidores que requieren alertas centralizadas | Plataforma de monitoreo dedicada |
| Despliegue controlado por versiones | Artefacto de compilación o versión confiable |
Un script personalizado es valioso cuando necesita una comprobación enfocada para su propio código y puede mantener su línea base y sus alertas.
3. ¿Por qué SHA-256?
PHP proporciona hash_file():
$hash = hash_file('sha256', '/path/to/file.php');
El resultado es un digest hexadecimal de 64 caracteres del contenido del archivo. Un archivo modificado casi con certeza producirá un digest diferente. Por lo tanto, podemos almacenar un mapa compacto de rutas relativas a valores SHA-256 en lugar de duplicar cada archivo.
Un digest coincidente demuestra consistencia con la referencia, no que la referencia o el archivo sean confiables. Establezca la instantánea inicial a partir de un despliegue verificado como bueno, preferiblemente comprobado contra el control de versiones o un paquete de versión aprobado.
4. Cree un escáner ligero de integridad de archivos PHP
Cree integrity-check.php fuera del directorio web público, junto a una línea base JSON protegida:
/home/account/
├── private/
│ ├── integrity-check.php
│ └── integrity-baseline.json
└── public_html/
├── index.php
├── includes/
└── plugins/
El script tiene dos comandos: baseline crea la instantánea inicial y scan la compara. Informa diferencias sin eliminar ni reemplazar archivos del sitio web. Esta versión también genera el registro formateado y la salida compatible con cron descritos en la sección 7.
Script PHP completo (PHP 7.4+)
<?php
declare(strict_types=1);
/**
* Lightweight file integrity scanner.
* Run from PHP CLI, outside the public web directory.
*/
$siteRoot = '/home/account/public_html';
$baselinePath = '/home/account/private/integrity-baseline.json';
$extensions = ['php', 'js', 'css'];
$excludedDirectories = [
'cache',
'tmp',
'logs',
'node_modules',
'vendor',
];
function collectFiles(
string $siteRoot,
array $extensions,
array $excludedDirectories
): array {
$files = [];
$directory = new RecursiveDirectoryIterator(
$siteRoot,
FilesystemIterator::SKIP_DOTS
);
$filter = new RecursiveCallbackFilterIterator(
$directory,
static function ($item) use ($excludedDirectories): bool {
if ($item->isLink()) {
return false;
}
if ($item->isDir()) {
return !in_array(
$item->getFilename(),
$excludedDirectories,
true
);
}
return $item->isFile();
}
);
$iterator = new RecursiveIteratorIterator($filter);
foreach ($iterator as $file) {
$filename = $file->getFilename();
$extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
if (
!in_array($extension, $extensions, true)
&& $filename !== '.htaccess'
) {
continue;
}
$fullPath = $file->getPathname();
$relativePath = str_replace(
DIRECTORY_SEPARATOR,
'/',
substr($fullPath, strlen($siteRoot) + 1)
);
$hash = hash_file('sha256', $fullPath);
if ($hash === false) {
throw new RuntimeException('Unable to hash: ' . $relativePath);
}
$files[$relativePath] = $hash;
}
ksort($files, SORT_STRING);
return $files;
}
function loadBaseline(string $baselinePath): array
{
if (!is_file($baselinePath)) {
throw new RuntimeException('Baseline not found. Run baseline first.');
}
$json = file_get_contents($baselinePath);
if ($json === false) {
throw new RuntimeException('Unable to read baseline.');
}
$data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
if (
!is_array($data)
|| ($data['version'] ?? null) !== 1
|| !isset($data['files'])
|| !is_array($data['files'])
) {
throw new RuntimeException('Invalid baseline format.');
}
return $data['files'];
}
try {
if (PHP_SAPI !== 'cli') {
throw new RuntimeException('CLI execution only.');
}
$command = $argv[1] ?? '';
if (!in_array($command, ['baseline', 'scan'], true)) {
throw new RuntimeException(
'Usage: php integrity-check.php baseline|scan'
);
}
$siteRoot = realpath($siteRoot);
if ($siteRoot === false || !is_dir($siteRoot)) {
throw new RuntimeException('Invalid website directory.');
}
$current = collectFiles(
$siteRoot,
$extensions,
$excludedDirectories
);
if ($command === 'baseline') {
if (file_exists($baselinePath)) {
throw new RuntimeException(
'Baseline already exists. Replace it only after '
. 'validating a trusted deployment.'
);
}
$payload = [
'version' => 1,
'created_at' => gmdate('c'),
'files' => $current,
];
$json = json_encode(
$payload,
JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR
);
if (file_put_contents($baselinePath, $json . PHP_EOL, LOCK_EX) === false) {
throw new RuntimeException('Unable to write baseline.');
}
chmod($baselinePath, 0600);
echo 'Baseline created: ' . count($current) . ' files' . PHP_EOL;
exit(0);
}
$baseline = loadBaseline($baselinePath);
$added = array_diff_key($current, $baseline);
$deleted = array_diff_key($baseline, $current);
$modified = [];
foreach (array_intersect_key($current, $baseline) as $path => $hash) {
if ($hash !== $baseline[$path]) {
$modified[$path] = $hash;
}
}
$changes = count($added) + count($modified) + count($deleted);
if ($changes === 0) {
exit(0);
}
$report = [
'========================================',
' WEBSITE FILE INTEGRITY REPORT',
'========================================',
'Site: ' . $siteRoot,
'Date: ' . gmdate('Y-m-d H:i:s') . ' UTC',
'Files checked: ' . count($current),
'Status: CHANGES DETECTED',
'',
'SUMMARY',
'----------------------------------------',
'Added: ' . count($added),
'Modified: ' . count($modified),
'Deleted: ' . count($deleted),
'Total: ' . $changes,
'',
'DETAILS',
'----------------------------------------',
];
foreach (array_keys($added) as $path) {
$report[] = '[ADDED] ' . $path;
}
foreach (array_keys($modified) as $path) {
$report[] = '[MODIFIED] ' . $path;
}
foreach (array_keys($deleted) as $path) {
$report[] = '[DELETED] ' . $path;
}
$report[] = '';
$report[] = '========================================';
$report[] = 'ACTION REQUIRED';
$report[] = 'Review unexpected changes against the';
$report[] = 'last approved deployment.';
$report[] = '========================================';
$reportText = implode(PHP_EOL, $report) . PHP_EOL;
$logDirectory = dirname($baselinePath) . '/logs';
if (!is_dir($logDirectory)) {
if (!mkdir($logDirectory, 0700, true) && !is_dir($logDirectory)) {
throw new RuntimeException('Unable to create log directory.');
}
}
$logPath = $logDirectory . '/integrity-' . gmdate('Y-m-d-His') . '.log';
if (file_put_contents($logPath, $reportText, LOCK_EX) === false) {
throw new RuntimeException('Unable to write integrity log.');
}
chmod($logPath, 0600);
// A cron mailer can deliver this standard output.
echo $reportText;
exit(2);
} catch (Throwable $exception) {
fwrite(STDERR, 'ERROR: ' . $exception->getMessage() . PHP_EOL);
exit(1);
}
El escáner omite enlaces simbólicos y directorios generados comunes. Revise las exclusiones con cuidado: un directorio escribible que contiene PHP ejecutable puede ser importante de monitorear. La línea base y los registros deben ser inaccesibles para el servidor web y estar protegidos contra escrituras no autorizadas.
5. Ejecute el primer escaneo
Edite $siteRoot y $baselinePath para que coincidan con su cuenta de alojamiento. Asegúrese de que el directorio privado exista y sea escribible por el usuario de CLI.
Después de verificar que el sitio web coincide con una versión verificada como buena, cree la línea base:
php /home/account/private/integrity-check.php baseline
Ejemplo:
Baseline created: 428 files
Ejecute una comparación:
php /home/account/private/integrity-check.php scan
Sin cambios, el escaneo finaliza correctamente y permanece silencioso. Modifique un archivo PHP inofensivo en una instalación de staging y ejecútelo de nuevo. El escáner generará un informe que identifica el archivo modificado.
6. Entienda los resultados
- ADDED: un archivo monitoreado existe ahora pero no en la línea base.
- MODIFIED: la misma ruta existe en ambas instantáneas, pero su digest SHA-256 difiere.
- DELETED: falta un archivo registrado en la línea base.
Primero revise el historial de despliegues y actualizaciones de extensiones. Si una diferencia no se explica, compare el archivo con su revisión Git aprobada o su paquete de versión. Investigue de inmediato el código sensible, como las integraciones de pago. Conserve la evidencia relevante en lugar de reemplazar ciegamente los archivos de producción.
7. Automatice las comprobaciones de integridad y reciba alertas por correo electrónico
Las comprobaciones manuales ayudan durante el desarrollo. Un escaneo programado es más útil cuando guarda un informe legible y lo envía por correo electrónico solo cuando algo cambia.
La mayoría de los paneles de control de alojamiento ofrecen tareas cron. El script completo de la sección 4 ya implementa el comportamiento necesario:
- Calcule los hashes actuales de los archivos.
- Compare con la línea base protegida.
- Si no hay diferencias, salga silenciosamente.
- De lo contrario, guarde un informe formateado bajo el directorio privado
logs/. - Imprima el mismo informe en la salida estándar para que un mailer de cron configurado pueda entregarlo.
Ejemplo de informe en texto plano
========================================
WEBSITE FILE INTEGRITY REPORT
========================================
Site: /home/account/public_html
Date: 2026-11-19 03:00:00 UTC
Files checked: 428
Status: CHANGES DETECTED
SUMMARY
----------------------------------------
Added: 1
Modified: 2
Deleted: 1
Total: 4
DETAILS
----------------------------------------
[ADDED] plugins/payment/debug.php
[MODIFIED] includes/bootstrap.php
[MODIFIED] plugins/payment/gateway.php
[DELETED] includes/legacy.php
========================================
ACTION REQUIRED
Review unexpected changes against the
last approved deployment.
========================================
El registro guardado podría ser:
/home/account/private/logs/integrity-2026-11-19-030000.log
Este informe funciona igual de bien en un editor de texto, un correo de notificación de cron o un ticket de incidente.
Programe el escáner
Una entrada tradicional de crontab para un escaneo diario a las 3 a. m.:

MAILTO=admin@example.com
0 3 * * * /usr/bin/php /home/account/private/integrity-check.php scan
Reemplace la dirección y las rutas por las suyas. El comportamiento de MAILTO de cron depende de la implementación de cron y de un transporte de correo funcional; algunos hosts compartidos ofrecen en su lugar notificaciones por correo electrónico en su panel de control. El script no envía correo electrónico por sí mismo. Imprime un informe para que el programador lo entregue.
Los códigos de salida son útiles para futuras integraciones:
| Código | Significado |
|---|---|
0 |
Escaneo limpio; sin salida |
1 |
Error del escáner; mensaje en el error estándar |
2 |
Diferencias detectadas; informe en la salida estándar |
Un mailer de cron convencional generalmente envía correo cuando un trabajo produce salida, no simplemente porque su estado de salida sea distinto de cero. Por eso el script imprime solo cuando hay cambios o errores.
Mantenga los registros bajo control
Una diferencia sin resolver vuelve a aparecer en cada escaneo, por lo que puede generar informes repetidos. Establezca un período de retención razonable (por ejemplo, 30 días) usando sus herramientas habituales de mantenimiento, y considere la deduplicación de alertas si amplía el escáner. El script de ejemplo guarda informes, pero no implementa limpieza automática de registros.
Nunca actualice la línea base automáticamente para silenciar alertas: investigue primero.
Pruebe la notificación
En staging, cree una línea base confiable, modifique un archivo PHP inofensivo, ejecute el escaneo y confirme que aparece un registro. Luego active la tarea programada y revise el correo electrónico. Restaure el archivo de prueba y confirme que el escáner vuelve a un estado limpio.
Si existe un registro pero no llega ningún correo electrónico, revise la configuración de notificaciones de cron del host y la entrega de correo. El escaneo de archivos y el transporte de correo son independientes.
8. Gestione actualizaciones legítimas sin falsas alarmas
Un despliegue normal puede modificar docenas de archivos. El escáner debería informar esos cambios, pero no debería tratarlos como una intrusión.
Un flujo de trabajo seguro es: desplegar una versión aprobada, verificar su contenido contra la fuente confiable, preservar la línea base anterior, crear una nueva línea base y luego reanudar las comprobaciones programadas.
El script de ejemplo se niega deliberadamente a sobrescribir una línea base existente. Para reemplazarla después de una versión aprobada, archive de forma segura la referencia anterior antes de crear la nueva.
Para proyectos gestionados con Git, una opción más sólida es generar los hashes esperados de los archivos a partir de una compilación aprobada o un artefacto de CI/CD, y entregar esa referencia de forma independiente del servidor de producción.
9. Conozca los límites
Los escaneos periódicos no detectan cambios temporales. Un archivo alterado y restaurado entre comprobaciones puede pasar desapercibido.
La línea base puede ser atacada. Un intruso con suficiente acceso para alterar tanto los archivos como los datos de referencia puede ocultar cambios. Mantenga una copia confiable independiente para sitios importantes.
La cobertura es selectiva. Nuestro ejemplo monitorea archivos PHP, JS, CSS y .htaccess, pero no bases de datos, cuentas de usuario, configuración de cron ni todos los tipos de archivo posibles. Sus exclusiones necesitan una revisión deliberada.
El monitoreo de integridad no es análisis de malware. Un hash cambiado indica que un archivo difiere, no si el cambio es malicioso.
Combine las comprobaciones de integridad con actualizaciones, acceso restringido, copias de seguridad, registros de la aplicación y herramientas de seguridad adecuadas.
10. Cuándo elegir una solución profesional
Un escáner PHP personalizado es compacto, auditable y fácil de integrar en el proceso de despliegue de una aplicación personalizada. Pero usted es responsable de las líneas base confiables, las exclusiones, la entrega de alertas, la retención de registros y la investigación.
Los productos de monitoreo consolidados pueden proporcionar paneles, historial de alertas, informes centralizados y funciones más amplias de respuesta a incidentes. Para WordPress y Joomla, comience revisando las capacidades ya disponibles a través de su plataforma y sus extensiones de seguridad.
Elija la solución confiable más pequeña que cubra sus necesidades operativas.
11. Lista de verificación práctica
- [ ] Verifique los archivos iniciales contra una versión confiable antes de crear la línea base.
- [ ] Almacene el script, la referencia y los informes fuera del directorio web público.
- [ ] Revise las extensiones monitoreadas y los directorios excluidos.
- [ ] Use permisos de sistema de archivos restringidos.
- [ ] Pruebe archivos añadidos, modificados y eliminados en staging.
- [ ] Confirme la ejecución de cron y la entrega real del correo.
- [ ] Conserve los registros y monitoree los errores del escáner.
- [ ] Reconstruya la línea base solo después de un despliegue aprobado.
- [ ] Investigue cambios inesperados en lugar de eliminar archivos automáticamente.
Conclusión: sepa qué cambió antes de investigar por qué
Un escáner de integridad de archivos ayuda a los desarrolladores a identificar rápidamente cambios inesperados en el sitio web. Las funciones nativas de hash de PHP hacen que la comparación sea simple; el valor real está en una línea base confiable, comprobaciones regulares, alertas legibles y un flujo de trabajo de despliegue controlado.
Para sitios PHP personalizados y extensiones, el script ligero anterior es un punto de partida útil sin Composer ni una base de datos. Para WordPress y Joomla, las herramientas consolidadas de verificación y seguridad pueden ser una mejor primera opción.