<?php

declare(strict_types=1);

namespace Sentinelo\Scanner\Checks;

// phpcs:disable WordPress.WP.AlternativeFunctions -- backups, snapshots and logs stream files of up to several GB in bounded chunks; WP_Filesystem has no streaming API and may need FTP credentials that a background REST request cannot ask for.

use Sentinelo\Scanner\CheckResult;

/**
 * Heuristic malware / webshell detection across wp-content code (plugins, themes,
 * mu-plugins) and uploads. Core files are intentionally NOT scanned here — they are
 * covered by CoreIntegrityCheck (checksums vs wordpress.org), which is stronger.
 *
 * Signatures are deliberately high-confidence COMBINATIONS (e.g. eval() of a decoded
 * payload, a superglobal piped into a shell) rather than bare tokens like
 * base64_decode — legitimate plugins use those constantly, so matching them alone
 * produces noise. Our own plugin, vendored libraries and caches are skipped.
 */
class SuspiciousFilesCheck
{
    private const DANGEROUS_EXTS = ['php', 'phtml', 'php5', 'php7', 'phar', 'cgi', 'pl', 'py', 'sh'];

    /** High-signal obfuscation / backdoor patterns. label => regex. */
    private const MALWARE_SIGNATURES = [
        'eval_decoded'       => '/\b(?:eval|assert)\s*\(\s*(?:base64_decode|gzinflate|gzuncompress|str_rot13|strrev|rawurldecode)\s*\(/i',
        'decode_chain'       => '/\b(?:gzinflate|gzuncompress|str_rot13)\s*\(\s*base64_decode\s*\(/i',
        'eval_superglobal'   => '/\b(?:eval|assert)\s*\(\s*\$_(?:GET|POST|REQUEST|COOKIE|SERVER)\b/i',
        'exec_superglobal'   => '/\b(?:system|exec|passthru|shell_exec|popen|proc_open)\s*\(\s*\$_(?:GET|POST|REQUEST|COOKIE)\b/i',
        'preg_replace_e'     => '/\bpreg_replace\s*\(\s*([\'"]).*?\/[a-z]*e[a-z]*\1/i',
        'create_function'    => '/\bcreate_function\s*\(\s*[\'"][^\'"]*[\'"]\s*,\s*(?:base64_decode|gzinflate|str_rot13)/i',
        'known_webshell'     => '/\b(?:c99shell|r57shell|FilesMan|b374k|phpspy|WSOshell|JFolder|by\s+orb)\b/i',
        'gif_php_polyglot'   => '/GIF89a\s*<\?php/i',
        'callback_decoded'   => '/\b(?:call_user_func|call_user_func_array)\s*\(\s*(?:base64_decode|gzinflate|str_rot13)\s*\(/i',
    ];

    private const READ_BYTES = 524288;   // read up to 512 KB per file
    private const MAX_FILE_SIZE = 3145728; // skip files > 3 MB
    private const MAX_FILES = 40000;      // hard cap to bound scan time

    public function run(): CheckResult
    {
        try {
            $suspicious = [];
            $scanned = 0;

            $selfDir = untrailingslashit(wp_normalize_path(SENTINELO_PLUGIN_DIR));

            // 1) plugins / themes / mu-plugins FIRST: this is where real webshells
            // hide and it isn't covered by any other check, so it must never be
            // starved of the shared MAX_FILES budget by a media-heavy uploads tree.
            $codeRoots = array_filter([
                WP_PLUGIN_DIR,
                get_theme_root(),
                WPMU_PLUGIN_DIR,
            ], 'is_dir');

            foreach (array_unique($codeRoots) as $root) {
                $this->scanCodeRoot($root, $selfDir, $suspicious, $scanned);
            }

            // 2) uploads/: executables + double-extensions + content signatures.
            $uploadsDir = wp_upload_dir(null, false)['basedir'] ?? '';
            if (is_dir($uploadsDir)) {
                $this->scanUploads($uploadsDir, $suspicious, $scanned);
            }

            $count = count($suspicious);
            $score = $count === 0 ? 15 : 0;
            $status = $count === 0 ? 'pass' : 'fail';

            return new CheckResult(
                'suspicious_files',
                $status,
                $score,
                15,
                'critical',
                array_slice($suspicious, 0, 100),
                $count === 0
                    ? "Aucun fichier suspect détecté ({$scanned} fichiers analysés)"
                    : sprintf('%d fichier(s) suspect(s) détecté(s) sur %d analysés', $count, $scanned)
            );
        } catch (\Throwable $e) {
            return new CheckResult(
                'suspicious_files',
                'skip',
                0,
                15,
                'info',
                ['error' => $e->getMessage()],
                'Vérification ignorée (exception interne) : ' . $e->getMessage()
            );
        }
    }

    private function scanUploads(string $uploadsDir, array &$suspicious, int &$scanned): void
    {
        $iterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($uploadsDir, \RecursiveDirectoryIterator::SKIP_DOTS)
        );

        foreach ($iterator as $file) {
            if (!$file->isFile() || $scanned >= self::MAX_FILES) {
                continue;
            }
            // The agent's own logs and encrypted archives (uploads/sentinelo/ in the
            // wordpress.org edition): nothing to analyse there.
            if (sentinelo_is_agent_storage($file->getPathname())) {
                continue;
            }
            $scanned++;

            $fileName = $file->getFilename();
            $extension = strtolower($file->getExtension());
            $relativePath = str_replace(ABSPATH, '', wp_normalize_path($file->getPathname()));

            if ($fileName === '.htaccess' || $fileName === 'index.php') {
                continue;
            }

            // Executable files have no business living in uploads/.
            //
            // Un fichier de CONFIGURATION protege par une garde fait exception, et
            // il faut la nommer : plusieurs extensions repandues ecrivent leur
            // configuration dans `uploads/` sous la forme `<nom>.ini.php`, ouverte
            // par `; <?php exit;`. C'est la maniere standard de rendre un fichier
            // de donnees illisible par HTTP — Matomo-for-WordPress fait exactement
            // cela. Le signaler en CRITIQUE sur chacun de ces sites vide le mot
            // « critique » de son sens, et c'est ainsi qu'on apprend a ignorer une
            // alerte. Mesure le 28 aout 2026 : le seul constat critique d'un site
            // client etait ce fichier-la, et il pesait 15 des 48 points perdus.
            //
            // On juge sur le CONTENU, jamais sur le nom : un nom se choisit, une
            // porte derobee doit s'executer. Voir isGuardedDataFile().
            if (in_array($extension, self::DANGEROUS_EXTS, true)) {
                if ($this->isGuardedDataFile($file->getPathname())) {
                    continue;
                }

                $suspicious[] = ['file' => $relativePath, 'reason' => 'Exécutable dans uploads/ : .' . $extension];
                continue;
            }

            // image.jpg.php style disguises.
            if (preg_match('/\.(jpg|jpeg|png|gif|pdf|doc|docx|zip)\.(php|phtml|php5|phar)$/i', $fileName)) {
                $suspicious[] = ['file' => $relativePath, 'reason' => 'Double extension suspecte'];
                continue;
            }

            if (($extension === 'php' || $extension === 'phtml') && ($hit = $this->matchSignatures($file->getPathname())) !== null) {
                $suspicious[] = ['file' => $relativePath, 'reason' => 'Signature malware : ' . $hit];
            }
        }
    }

    private function scanCodeRoot(string $root, string $selfDir, array &$suspicious, int &$scanned): void
    {
        $iterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($root, \RecursiveDirectoryIterator::SKIP_DOTS)
        );

        foreach ($iterator as $file) {
            if (!$file->isFile() || $scanned >= self::MAX_FILES) {
                continue;
            }

            $extension = strtolower($file->getExtension());
            if ($extension !== 'php' && $extension !== 'phtml') {
                continue;
            }

            $normalized = wp_normalize_path($file->getPathname());
            // Skip our own plugin, vendored deps, caches and VCS — all expected to
            // contain encode/eval-ish tokens or be noise.
            if (
                str_starts_with($normalized, $selfDir)
                || preg_match('#/(?:vendor|node_modules|\.git|cache|tests?)/#i', $normalized)
            ) {
                continue;
            }

            $scanned++;
            if (($hit = $this->matchSignatures($normalized)) !== null) {
                $suspicious[] = [
                    'file'   => str_replace(ABSPATH, '', $normalized),
                    'reason' => 'Signature malware : ' . $hit,
                ];
            }
        }
    }

    /**
     * Un fichier de donnees rendu inexecutable par une garde en tete.
     *
     * Le motif : le fichier ouvre par `<?php exit;` (souvent precede d'un `;` de
     * commentaire INI), puis ne contient PLUS AUCUNE balise ouvrante. Tout ce qui
     * suit la garde est du texte litteral que PHP n'atteindra jamais — le fichier
     * ne peut donc rien executer, quel que soit son nom.
     *
     * Les deux conditions comptent, et la seconde surtout : une porte derobee qui
     * se deguiserait en `config.ini.php` devrait rouvrir une balise pour agir, et
     * elle serait signalee. Se fier au nom seul serait exactement l'erreur — un
     * nom se choisit, une execution non.
     *
     * On ne lit que le debut du fichier : la garde est en tete par construction, et
     * un fichier de configuration peut peser plusieurs centaines de kilo-octets.
     */
    private function isGuardedDataFile(string $path): bool
    {
        $handle = @fopen($path, 'rb');
        if ($handle === false) {
            // Illisible : on ne conclut pas a l'innocence. Le check reprend son
            // cours normal et le fichier sera signale.
            return false;
        }

        $head = (string) fread($handle, 4096);
        fclose($handle);

        // La garde doit ouvrir le fichier, pas s'y trouver quelque part.
        if (preg_match('/^\s*;?\s*<\?php\s+(?:exit|die)\s*(?:\(\s*\)\s*)?;/i', $head) !== 1) {
            return false;
        }

        // Et rien ne doit rouvrir apres elle — ni dans l'entete lu, ni plus loin.
        $rest = (string) file_get_contents($path, false, null, strlen($this->guardPrefix($head)));

        return !str_contains($rest, '<?php') && !str_contains($rest, '<?=');
    }

    /** La garde elle-meme, telle qu'elle apparait en tete de fichier. */
    private function guardPrefix(string $head): string
    {
        return preg_match('/^\s*;?\s*<\?php\s+(?:exit|die)\s*(?:\(\s*\)\s*)?;(?:\s*\?>)?/i', $head, $m) === 1
            ? $m[0]
            : '';
    }

    /** Returns the matched signature label, or null. */
    private function matchSignatures(string $path): ?string
    {
        if (filesize($path) > self::MAX_FILE_SIZE) {
            return null;
        }
        $handle = @fopen($path, 'rb');
        if ($handle === false) {
            return null;
        }
        $content = (string) fread($handle, self::READ_BYTES);
        fclose($handle);

        foreach (self::MALWARE_SIGNATURES as $label => $regex) {
            if (preg_match($regex, $content)) {
                return $label;
            }
        }
        return null;
    }
}