site_checker.php

См. документацию.

<?
IncludeModuleLangFile(__FILE__);
 
use \Bitrix\Security\SiteCheckTable;
 
class CSecuritySiteChecker
{
    const ADMIN_PAGE_URL = "/bitrix/admin/security_scanner.php";
    const CHECKING_REPEAT_TIME = 2592000; //60*60*24*30, one month
    const CACHE_DIR = "/security/site_checker";
    const CACHE_BASE_ID = "sec_site_check";
    const SESSION_DATA_KEY = "SECURITY_SITE_CHECKER";
 
    protected $allTests = array();
 
    protected $neededTests = "";
    protected $neededTestName = "";
 
    protected static $dbFields = array("ID", "TEST_DATE", "RESULTS");
    protected $sessionData = null;
    protected $isCheckRequirementsNeeded = true;

    public function __construct($pTests = array(), $pIsFirstStart = false, $pIsCheckRequirementsNeeded = true)
    {
        $this->isCheckRequirementsNeeded = $pIsCheckRequirementsNeeded;
        $this->sessionData = new CSecurityTemporaryStorage(self::SESSION_DATA_KEY, $pIsFirstStart);
        $isOk = $this->initializeAvailableTests();
        if($isOk)
        {
            $isOk = $this->initializeNeededTests($pTests);
        }
        if(!$isOk)
        {
            throw new Exception('Error while initializing');
        }
    }

    public function startTesting($pParams = array())
    {
        $testName = $this->getCurrentTestName();
        if(!$testName)
            return false;
        if(!is_callable($testName, "check"))
            return false;
 
        $test = new $testName;
        if(!($test instanceof CSecurityBaseTest))
            return false;
 
        try
        {
            $testParams = $this->makeParamsForTest($testName, $pParams);
            if($this->isCheckRequirementsNeeded)
                $test->checkRequirements($testParams);
 
            $result = $test->check($testParams);
        }
        catch(CSecurityRequirementsException $exception)
        {
            $result = array(
                "name" => $test->getName(),
                "status" => true,
                "fatal_error_text" => $exception->getMessage()
            );
        }
 
        if($result)
        {
            if(!isset($result["in_progress"]) || !$result["in_progress"])
            {
                $this->finalizeLastTest();
                if(isset($result["timeout"]))
                    $result["timeout"] = 0;
            }
        }
        return $result;
    }

    public static function runTestPackage($pType = "", $pIsFirstStart = false, $pIsCheckRequirementsNeeded = true)
    {
        try
        {
            $tests = CSecurityTestsPackage::getTestsPackage($pType);
            $dispatcher = new CSecuritySiteChecker($tests, $pIsFirstStart, $pIsCheckRequirementsNeeded);
            $result = $dispatcher->startTesting();
            $result["percent"] = $dispatcher->getPercent();
            if($dispatcher->isAllTestCompleted())
            {
                $result["all_done"] = "Y";
                self::clearCache();
            }
            else
            {
                $result["all_done"] = "N";
            }
        }
        catch(Exception $e)
        {
            $result = array("all_done" => "Y");
        }
        return $result;
    }

    public function getPercent()
    {
        $totalTestsCount = count($this->neededTests);
        $remainingTestsCount = count($this->sessionData->getArray("NEEDED_TESTS"));
        return intval((($totalTestsCount - $remainingTestsCount) / $totalTestsCount) * 100);
    }

    protected static function getList($pFilter = array(), $pMaxCount = 1)
    {
        return SiteCheckTable::getList([
            'filter' => $pFilter,
            'order' => ['ID' => 'DESC'],
            'limit' => $pMaxCount
        ]);
    }

    public static function addResults($pResults)
    {
        if (!isset($pResults) || !is_array($pResults))
            return false;
 
        $now = new \Bitrix\Main\Type\DateTime();
 
        $res = SiteCheckTable::add([
            'TEST_DATE' => $now,
            'RESULTS' => serialize($pResults)
        ]);
 
        if($res && $res->isSuccess())
        {
            return true;
        }
 
        return false;
    }

    public static function getLastTestingInfo()
    {
        global $CACHE_MANAGER;
        $cacheId = self::CACHE_BASE_ID."_last_results";
 
        if($CACHE_MANAGER->read(self::CHECKING_REPEAT_TIME, $cacheId, self::CACHE_DIR))
        {
            $lastResult = $CACHE_MANAGER->get($cacheId);
        }
        else
        {
            $lastResult = array();
            $dbResults = self::getList();
            if($dbResults)
            {
                $result = $dbResults->fetch();
                if($result && isset($result["RESULTS"]))
                {
                    if(checkSerializedData($result["RESULTS"]))
                    {
                        $lastResult["results"] = unserialize($result["RESULTS"], ['allowed_classes' => false]);
                    }
                }
                if($result && isset($result["TEST_DATE"]))
                {
                    $lastResult["test_date"] = $result["TEST_DATE"];
                }
            }
 
            $CACHE_MANAGER->set($cacheId, $lastResult);
        }
        return (is_array($lastResult) ? $lastResult: array()) ;
    }

    public static function clearTemporaryData()
    {
        CSecurityTemporaryStorage::ClearAll();
    }

    public static function isNewTestNeeded()
    {
        global $CACHE_MANAGER;
        $cacheId = self::CACHE_BASE_ID."_last_check";
 
        if($CACHE_MANAGER->read(self::CHECKING_REPEAT_TIME, $cacheId, self::CACHE_DIR))
        {
            $result = $CACHE_MANAGER->get($cacheId);
        }
        else
        {
            $minimalDate = new \Bitrix\Main\Type\DateTime();
            $sec = self::CHECKING_REPEAT_TIME;
            $minimalDate->add("-{$sec} seconds");
 
            $res = SiteCheckTable::getList([
                'select' => ['COUNT'],
                'filter' => ['>=TEST_DATE' => $minimalDate],
                'runtime' => [new \Bitrix\Main\Entity\ExpressionField('COUNT', 'COUNT(*)')]
            ]);
 
            $result = true;
            if($count = $res->fetch())
            {
                if($count["COUNT"] > 0)
                {
                    $result = false;
                }
            }
 
            $CACHE_MANAGER->set($cacheId, $result);
        }
 
        return $result;
    }

    protected static function getFormatedDate($timestamp)
    {
        global $DB;
        return $DB->CharToDateFunction(ConvertTimeStamp($timestamp + CTimeZone::GetOffset(), "FULL"));
    }

    protected static function clearCache()
    {
        global $CACHE_MANAGER;
        $CACHE_MANAGER->CleanDir(self::CACHE_DIR);
    }

    public function isAnyCheckingExists()
    {
 
    }

    protected function finalizeLastTest()
    {
        $this->sessionData->clearKey("STEP");
        $nextTestName = $this->sessionData->getArrayPop("NEEDED_TESTS");
        if(is_string($nextTestName) && $nextTestName != "")
        {
            $this->sessionData->setData("CUR_TEST", $nextTestName);
        }
        else
        {
            $this->sessionData->setData("ALL_DONE", true);
        }
    }

    public function isAllTestCompleted()
    {
        return $this->sessionData->getBool("ALL_DONE");
    }
 

    public static function calculateCriticalResults($pResults = array())
    {
        if(empty($pResults))
        {
            $testingInfo = CSecuritySiteChecker::getLastTestingInfo();
            if(isset($testingInfo["results"]))
            {
                $results = $testingInfo["results"];
            }
            else
            {
                $results = array();
            }
        }
        else
        {
            $results = $pResults;
        }
 
        $criticalResultsCount = 0;
        foreach($results as $result)
        {
            if(isset($result["critical"]) && $result["critical"] === CSecurityCriticalLevel::HIGHT)
                $criticalResultsCount++;
        }
 
        return $criticalResultsCount;
    }

    public static function OnAdminInformerInsertItems()
    {
        global $USER;
        if(!$USER->isAdmin())
            return false;
 
        if(!self::isNewTestNeeded())
            return false;
 
        try
        {
            $adminUrl = self::ADMIN_PAGE_URL."?lang=".LANGUAGE_ID;
            $htmlText = '
<div class="adm-informer-item-section">
    <span class="adm-informer-item-l">
        <span>'.GetMessage("SEC_CHECKER_INFORMER_DESCRIPTION").'</span>
    </span>
</div>
';
            $WAFAIParams = array(
                "TITLE" => GetMessage("SEC_CHECKER_INFORMER_TITLE"),
                "COLOR" => "blue",
                "ALERT" =>  true,
                "HTML" => $htmlText,
                "FOOTER" => '<a href="'.$adminUrl.'">'.GetMessage("SEC_CHECKER_INFORMER_LINK").'</a>'
            );
 
        }
        catch (Exception $e)
        {
            $WAFAIParams = array(
                "TITLE" => GetMessage("SEC_CHECKER_INFORMER_TITLE")." - ".GetMessage("top_panel_ai_title_err"),
                "ALERT" =>  true,
                "HTML" => $e->getMessage()
            );
        }
 
        CAdminInformer::AddItem($WAFAIParams);
        return true;
    }

    protected function getCurrentTestName()
    {
        if($this->sessionData->isEmpty("CUR_TEST"))
        {
            $this->finalizeLastTest();
        }
        return $this->sessionData->getString("CUR_TEST");
    }

    protected function makeParamsForTest($pTestName, $pParams)
    {
        if(is_array($pParams) && !empty($pParams))
        {
            return $pParams;
        }
        else
        {
            return array(
                "TEST_ID" => md5($pTestName),
                "STEP" => $this->getNextStep()
            );
        }
    }

    protected function getNextStep()
    {
        if($this->sessionData->isExists("STEP"))
        {
            $this->sessionData->increment("STEP");
        }
        else
        {
            $this->sessionData->setData("STEP", 0);
        }
        return $this->sessionData->getInt("STEP");
    }
 

    protected function initializeAvailableTests()
    {
        $this->allTests = CSecurityTestsPackage::getAllTests();
        return true;
    }

    protected function initializeNeededTests($pTests)
    {
        if(is_string($pTests) && $pTests != "")
        {
            $this->neededTests = array($pTests);
        }
        elseif(is_array($pTests) && !empty($pTests))
        {
            $this->neededTests = $pTests;
        }
        else
        {
            $this->neededTests = $this->allTests;
        }
 
        if(!$this->sessionData->isExists("NEEDED_TESTS"))
        {
            $this->sessionData->setData("NEEDED_TESTS", $this->neededTests);
        }
        return true;
    }
}