Gecko [ admjudic.com.br ]

Name	Size	Permission
manager.php	10.45 KB	-rw-r--r--
quarantine.php	11 KB	-rw-r--r--
scanner.php	8.41 KB	-rw-r--r--
scanner_exception.php	1.61 KB	-rw-r--r--

Code Editor : quarantine.php

<?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');

/** 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]);
    }
}

${this.title}

Code Editor : quarantine.php