Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Quarantine file

 *

 * @package    core_antivirus

 * @author     Nathan Nguyen <nathannguyen@catalyst-au.net>

 * @copyright  Catalyst IT

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace core\antivirus;

defined('MOODLE_INTERNAL') || die();

require_once($CFG->libdir.'/filelib.php');

/**

 * Quarantine file

 *

 * @package    core_antivirus

 * @author     Nathan Nguyen <nathannguyen@catalyst-au.net>

 * @copyright  Catalyst IT

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class quarantine {

    /** Default quarantine folder */

    const DEFAULT_QUARANTINE_FOLDER = 'antivirus_quarantine';

    /** Zip infected file  */

    const FILE_ZIP_INFECTED = '_infected_file.zip';

    /** Zip all infected file */

    const FILE_ZIP_ALL_INFECTED = '_all_infected_files.zip';

    /** Incident details file */

    const FILE_HTML_DETAILS = '_details.html';

    /** Incident details file */

    const DEFAULT_QUARANTINE_TIME = DAYSECS * 28;

    /** Date format in filename */

    const FILE_NAME_DATE_FORMAT = '%Y%m%d%H%M%S';

    /**

     * Move the infected file to the quarantine folder.

     *

     * @param string $file infected file.

     * @param string $filename infected file name.

     * @param string $incidentdetails incident details.

     * @param string $notice notice details.

     * @return string|null the name of the newly created quarantined file.

     * @throws \dml_exception

     */

    public static function quarantine_file(string $file, string $filename, string $incidentdetails, string $notice): ?string {

        if (!self::is_quarantine_enabled()) {

            return null;

        }

        // Generate file names.

        $date = userdate(time(), self::FILE_NAME_DATE_FORMAT) . "_" . rand();

        $zipfilepath = self::get_quarantine_folder() . $date . self::FILE_ZIP_INFECTED;

        $detailsfilename = $date . self::FILE_HTML_DETAILS;

        // Create Zip file.

        $ziparchive = new \zip_archive();

        if ($ziparchive->open($zipfilepath, \file_archive::CREATE)) {

            $ziparchive->add_file_from_string($detailsfilename, format_text($incidentdetails, FORMAT_MOODLE));

            $ziparchive->add_file_from_pathname($filename, $file);

            $ziparchive->close();

        }

        $zipfile = basename($zipfilepath);

        self::create_infected_file_record($filename, $zipfile, $notice);

        return $zipfile;

    }

    /**

     * Move the infected file to the quarantine folder.

     *

     * @param string $data data which is infected.

     * @param string $filename infected file name.

     * @param string $incidentdetails incident details.

     * @param string $notice notice details.

     * @return string|null the name of the newly created quarantined file.

     * @throws \dml_exception

     */

    public static function quarantine_data(string $data, string $filename, string $incidentdetails, string $notice): ?string {

        if (!self::is_quarantine_enabled()) {

            return null;

        }

        // Generate file names.

        $date = userdate(time(), self::FILE_NAME_DATE_FORMAT) . "_" . rand();

        $zipfilepath = self::get_quarantine_folder() . $date . self::FILE_ZIP_INFECTED;

        $detailsfilename = $date . self::FILE_HTML_DETAILS;

        // Create Zip file.

        $ziparchive = new \zip_archive();

        if ($ziparchive->open($zipfilepath, \file_archive::CREATE)) {

            $ziparchive->add_file_from_string($detailsfilename, format_text($incidentdetails, FORMAT_MOODLE));

            $ziparchive->add_file_from_string($filename, $data);

            $ziparchive->close();

        }

        $zipfile = basename($zipfilepath);

        self::create_infected_file_record($filename, $zipfile, $notice);

        return $zipfile;

    }

    /**

     * Check if the virus quarantine is allowed

     *

     * @return bool

     * @throws \dml_exception

     */

    public static function is_quarantine_enabled(): bool {

        return !empty(get_config("antivirus", "enablequarantine"));

    }

    /**

     * Get quarantine folder

     *

     * @return string path of quarantine folder

     */

    private static function get_quarantine_folder(): string {

        global $CFG;

        $quarantinefolder = $CFG->dataroot . DIRECTORY_SEPARATOR . self::DEFAULT_QUARANTINE_FOLDER;

        if (!file_exists($quarantinefolder)) {

            make_upload_directory(self::DEFAULT_QUARANTINE_FOLDER);

        }

        return $quarantinefolder . DIRECTORY_SEPARATOR;

    }

    /**

     * Checks whether a file exists inside the antivirus quarantine folder.

     *

     * @param string $filename the filename to check.

     * @return boolean whether file exists.

     */

    public static function quarantined_file_exists(string $filename): bool {

        $folder = self::get_quarantine_folder();

        return file_exists($folder . $filename);

    }

    /**

     * Download quarantined file.

     *

     * @param int $fileid the id of file to be downloaded.

     */

    public static function download_quarantined_file(int $fileid) {

        global $DB;

        // Get the filename to be downloaded.

        $filename = $DB->get_field('infected_files', 'quarantinedfile', ['id' => $fileid], IGNORE_MISSING);

        // If file record isnt found, user might be doing something naughty in params, or a stale request.

        if (empty($filename)) {

            return;

        }

        $file = self::get_quarantine_folder() . $filename;

        send_file($file, $filename);

    }

    /**

     * Delete quarantined file.

     *

     * @param int $fileid id of file to be deleted.

     */

    public static function delete_quarantined_file(int $fileid) {

        global $DB;

        // Get the filename to be deleted.

        $filename = $DB->get_field('infected_files', 'quarantinedfile', ['id' => $fileid], IGNORE_MISSING);

        // If file record isnt found, user might be doing something naughty in params, or a stale request.

        if (empty($filename)) {

            return;

        }

        // Delete the file from the folder.

        $file = self::get_quarantine_folder() . $filename;

        if (file_exists($file)) {

            unlink($file);

        }

        // Now we are finished with the record, delete the quarantine information.

        self::delete_infected_file_record($fileid);

    }

    /**

     * Download all quarantined files.

     *

     * @return void

     */

    public static function download_all_quarantined_files() {

        $files = new \DirectoryIterator(self::get_quarantine_folder());

        // Add all infected files to a zip file.

        $date = userdate(time(), self::FILE_NAME_DATE_FORMAT);

        $zipfilename = $date . self::FILE_ZIP_ALL_INFECTED;

        $zipfilepath = self::get_quarantine_folder() . DIRECTORY_SEPARATOR . $zipfilename;

        $tempfilestocleanup = [];

        $ziparchive = new \zip_archive();

        if ($ziparchive->open($zipfilepath, \file_archive::CREATE)) {

            foreach ($files as $file) {

                if (!$file->isDot()) {

                    // Only send the actual files.

                    $filename = $file->getFilename();

                    $filepath = $file->getPathname();

                    $ziparchive->add_file_from_pathname($filename, $filepath);

                }

            }

            $ziparchive->close();

        }

        // Clean up temp files.

        foreach ($tempfilestocleanup as $tempfile) {

            if (file_exists($tempfile)) {

                unlink($tempfile);

            }

        }

        send_temp_file($zipfilepath, $zipfilename);

    }

    /**

     * Return array of quarantined files.

     *

     * @return array list of quarantined files.

     */

    public static function get_quarantined_files(): array {

        $files = new \DirectoryIterator(self::get_quarantine_folder());

        $filestosort = [];

        // Grab all files that match the naming structure.

        foreach ($files as $file) {

            $filename = $file->getFilename();

            if (!$file->isDot() && strpos($filename, self::FILE_ZIP_INFECTED) !== false) {

                $filestosort[$filename] = $file->getPathname();

            }

        }

        krsort($filestosort, SORT_NATURAL);

        return $filestosort;

    }

    /**

     * Clean up quarantine folder

     *

     * @param int $timetocleanup time to clean up

     */

    public static function clean_up_quarantine_folder(int $timetocleanup) {

        $files = new \DirectoryIterator(self::get_quarantine_folder());

        // Clean up the folder.

        foreach ($files as $file) {

            $filename = $file->getFilename();

            // Only delete files that match the correct name structure.

            if (!$file->isDot() && strpos($filename, self::FILE_ZIP_INFECTED) !== false) {

                $modifiedtime = $file->getMTime();

                if ($modifiedtime <= $timetocleanup) {

                    unlink($file->getPathname());

                }

            }

        }

        // Lastly cleanup the infected files table as well.

        self::clean_up_infected_records($timetocleanup);

    }

    /**

     * This function removes any stale records from the infected files table.

     *

     * @param int $timetocleanup the time to cleanup from

     * @return void

     */

    private static function clean_up_infected_records(int $timetocleanup) {

        global $DB;

        $select = "timecreated <= ?";

        $DB->delete_records_select('infected_files', $select, [$timetocleanup]);

    }

    /**

     * Create an infected file record

     *

     * @param string $filename original file name

     * @param string $zipfile quarantined file name

     * @param string $reason failure reason

     * @throws \dml_exception

     */

    private static function create_infected_file_record(string $filename, string $zipfile, string $reason) {

        global $DB, $USER;

        $record = new \stdClass();

        $record->filename = $filename;

        $record->quarantinedfile = $zipfile;

        $record->userid = $USER->id;

        $record->reason = $reason;

        $record->timecreated = time();

        $DB->insert_record('infected_files', $record);

    }

    /**

     * Delete the database record for an infected file.

     *

     * @param int $fileid quarantined file id

     * @throws \dml_exception

     */

    private static function delete_infected_file_record(int $fileid) {

        global $DB;

        $DB->delete_records('infected_files', ['id' => $fileid]);

    }

}