PHP Decode

<?  $agentFiles = unserialize(base64_decode('a:21:{s:8:"http.php";s:1398:"<?php

error_reporting(E_ALL);
ini_set('display_errors', 1);

$authenticated = false;
try {
    // Parse request
    $request = GravityscanRequest::createFromGlobals();
    $gravityscanAgent = new GravityscanAgent($request, new GravityscanResponse);

    if ($request->getMethod() === 'GET') {
        $gravityscanAgent->getResponse()
            ->setStatusCode(200)
            ->setHeader('Content-Type', 'text/html')
            ->setBody(gsIncludeFile('diagnostics.php'))
            ->send();
    }

    // Authentication
    $gravityscanAuth = new GravityscanAgentAuth();
    $gravityscanAuth->setSignature(pack("H*", $request->getHeader('X-Gravityscan-Signature')))
        ->setMessage($request->getBody())
        ->setPublicKey(gsConfig('public_key'))
        ->authenticate();

    $authenticated = true;

    // Issue commands
    $gravityscanAgent->run();

} catch (GravityscanException $e) {
    $gravityscanAgent->getResponse()
        ->setStatusCode($e->getCode())
        ->setJson(array(
            'code'  => $e->getCode(),
            'error' => $e->getMessage(),
        ))
        ->send();

} catch (Exception $e) {
    $gravityscanAgent->getResponse()
        ->setStatusCode(500)
        ->setJson(array(
            'code'  => 500,
            'error' => $authenticated ? $e->getMessage() : 'There was an error processing your request.',
        ))
        ->send();
}
";s:32:"classes/GravityscanAgentAuth.php";s:2613:"<?php

class GravityscanAgentAuth
{
    private $signature;
    private $message;
    private $publicKey;

    /**
     * @param string $signature
     * @param string $message
     * @param string $publicKey
     */
    public function __construct($signature = null, $message = null, $publicKey = null)
    {
        $this->signature = $signature;
        $this->message = $message;
        $this->publicKey = $publicKey;
    }

    /**
     * @return bool
     * @throws GravityscanException
     */
    public function authenticate()
    {
        // Verify signature is correct
        if (!$this->verifySignature()) {
            throw new GravityscanException('Access denied.', 403);
        }

        // Check that the message has not expired.
        $jsonBody = @json_decode($this->getMessage(), true);
        if (!$jsonBody) {
            throw new GravityscanException('Error parsing the JSON request body. Error code: ' . json_last_error(), 422);
        }
        if (!isset($jsonBody['issued-at']) || !isset($jsonBody['expires-at'])) {
            throw new GravityscanException('`issued-at` and `expires-at` timestamps must be supplied in the request body.', 422);
        }
        $now = microtime(true);
        if (!($jsonBody['issued-at'] <= $now && $jsonBody['expires-at'] >= $now)) {
            throw new GravityscanException('Request has expired. Current server time is ' . $now, 422);
        }

        return true;
    }

    /**
     * @return bool
     */
    public function verifySignature()
    {
        return openssl_verify($this->getMessage(), $this->getSignature(), $this->getPublicKey(), OPENSSL_ALGO_SHA1) === 1;
    }

    /**
     * @param string $signature
     * @return GravityscanAgentAuth
     */
    public function setSignature($signature)
    {
        $this->signature = $signature;
        return $this;
    }

    /**
     * @return string
     */
    public function getSignature()
    {
        return $this->signature;
    }

    /**
     * @param string $message
     * @return GravityscanAgentAuth
     */
    public function setMessage($message)
    {
        $this->message = $message;
        return $this;
    }

    /**
     * @return string
     */
    public function getMessage()
    {
        return $this->message;
    }

    /**
     * @param string $publicKey
     * @return GravityscanAgentAuth
     */
    public function setPublicKey($publicKey)
    {
        $this->publicKey = $publicKey;
        return $this;
    }

    /**
     * @return string
     */
    public function getPublicKey()
    {
        return $this->publicKey;
    }
}";s:28:"classes/GravityscanUtils.php";s:7467:"<?php

class GravityscanUtils
{
    public static function getRandomString($length = 16, $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_ []{}<>~`+=,.;:/?|')
    {
        // This is faster than calling self::random_int for $length
        $bytes = self::random_bytes($length);
        $return = '';
        $maxIndex = self::strlen($chars) - 1;
        for ($i = 0; $i < $length; $i++) {
            $fp = (float)ord($bytes[$i]) / 255.0; // convert to [0,1]
            $index = (int)(round($fp * $maxIndex));
            $return .= $chars[$index];
        }
        return $return;
    }

    /**
     * Polyfill for random_bytes.
     *
     * @param int $bytes
     * @return string
     */
    public static function random_bytes($bytes)
    {
        $bytes = (int)$bytes;
        if (function_exists('random_bytes')) {
            try {
                $rand = random_bytes($bytes);
                if (is_string($rand) && self::strlen($rand) === $bytes) {
                    return $rand;
                }
            } catch (Exception $e) {
                // Fall through
            } catch (TypeError $e) {
                // Fall through
            } catch (Error $e) {
                // Fall through
            }
        }
        if (function_exists('mcrypt_create_iv')) {
            $rand = @mcrypt_create_iv($bytes, MCRYPT_DEV_URANDOM);
            if (is_string($rand) && self::strlen($rand) === $bytes) {
                return $rand;
            }
        }
        if (function_exists('openssl_random_pseudo_bytes')) {
            $rand = @openssl_random_pseudo_bytes($bytes, $strong);
            if (is_string($rand) && self::strlen($rand) === $bytes) {
                return $rand;
            }
        }
        // Last resort is insecure
        $return = '';
        for ($i = 0; $i < $bytes; $i++) {
            $return .= chr(mt_rand(0, 255));
        }
        return $return;
    }

    /**
     * Polyfill for random_int.
     *
     * @param int $min
     * @param int $max
     * @return int
     */
    public static function random_int($min = 0, $max = 0x7FFFFFFF)
    {
        if (function_exists('random_int')) {
            try {
                return random_int($min, $max);
            } catch (Exception $e) {
                // Fall through
            } catch (TypeError $e) {
                // Fall through
            } catch (Error $e) {
                // Fall through
            }
        }
        $diff = $max - $min;
        $bytes = self::random_bytes(4);
        if ($bytes === false || self::strlen($bytes) != 4) {
            throw new RuntimeException("Unable to get 4 bytes");
        }
        $val = unpack("Nint", $bytes);
        $val = $val['int'] & 0x7FFFFFFF;
        $fp = (float)$val / 2147483647.0; // convert to [0,1]
        return (int)(round($fp * $diff) + $min);
    }

    /**
     * Set the mbstring internal encoding to a binary safe encoding when func_overload
     * is enabled.
     *
     * When mbstring.func_overload is in use for multi-byte encodings, the results from
     * strlen() and similar functions respect the utf8 characters, causing binary data
     * to return incorrect lengths.
     *
     * This function overrides the mbstring encoding to a binary-safe encoding, and
     * resets it to the users expected encoding afterwards through the
     * `reset_mbstring_encoding` function.
     *
     * It is safe to recursively call this function, however each
     * `mbstring_binary_safe_encoding()` call must be followed up with an equal number
     * of `reset_mbstring_encoding()` calls.
     *
     * @see wfWAFUtils::reset_mbstring_encoding
     *
     * @staticvar array $encodings
     * @staticvar bool  $overloaded
     *
     * @param bool $reset Optional. Whether to reset the encoding back to a previously-set encoding.
     *                    Default false.
     */
    public static function mbstring_binary_safe_encoding($reset = false)
    {
        static $encodings = array();
        static $overloaded = null;

        if (is_null($overloaded))
            $overloaded = function_exists('mb_internal_encoding') && (ini_get('mbstring.func_overload') & 2);

        if (false === $overloaded)
            return;

        if (!$reset) {
            $encoding = mb_internal_encoding();
            array_push($encodings, $encoding);
            mb_internal_encoding('ISO-8859-1');
        }

        if ($reset && $encodings) {
            $encoding = array_pop($encodings);
            mb_internal_encoding($encoding);
        }
    }

    /**
     * Reset the mbstring internal encoding to a users previously set encoding.
     *
     * @see wfWAFUtils::mbstring_binary_safe_encoding
     */
    public static function reset_mbstring_encoding()
    {
        self::mbstring_binary_safe_encoding(true);
    }

    /**
     * @param callable $function
     * @param array $args
     * @return mixed
     */
    protected static function callMBSafeStrFunction($function, $args)
    {
        self::mbstring_binary_safe_encoding();
        $return = call_user_func_array($function, $args);
        self::reset_mbstring_encoding();
        return $return;
    }

    /**
     * Multibyte safe strlen.
     *
     * @param $binary
     * @return int
     */
    public static function strlen($binary)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('strlen', $args);
    }

    /**
     * @param $haystack
     * @param $needle
     * @param int $offset
     * @return int
     */
    public static function stripos($haystack, $needle, $offset = 0)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('stripos', $args);
    }

    /**
     * @param $string
     * @return mixed
     */
    public static function strtolower($string)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('strtolower', $args);
    }

    /**
     * @param $string
     * @param $start
     * @param $length
     * @return mixed
     */
    public static function substr($string, $start, $length = null)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('substr', $args);
    }

    /**
     * @param $haystack
     * @param $needle
     * @param int $offset
     * @return mixed
     */
    public static function strpos($haystack, $needle, $offset = 0)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('strpos', $args);
    }

    /**
     * @param string $haystack
     * @param string $needle
     * @param int $offset
     * @param int $length
     * @return mixed
     */
    public static function substr_count($haystack, $needle, $offset = 0, $length = null)
    {
        $haystack = self::substr($haystack, $offset, $length);
        return self::callMBSafeStrFunction('substr_count', array(
            $haystack, $needle,
        ));
    }

    /**
     * @param $string
     * @return mixed
     */
    public static function strtoupper($string)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('strtoupper', $args);
    }

    /**
     * @param string $haystack
     * @param string $needle
     * @param int $offset
     * @return mixed
     */
    public static function strrpos($haystack, $needle, $offset = 0)
    {
        $args = func_get_args();
        return self::callMBSafeStrFunction('strrpos', $args);
    }


}";s:35:"classes/GravityscanLocalStorage.php";s:1328:"<?php

interface GravityscanLocalStorage
{
    public function initialize();

    public function has($key);

    public function set($key, $value);

    public function get($key);

    public function delete($key);

    public function destroy();
}

class GravityscanLocalStorageSession implements GravityscanLocalStorage
{

    public function initialize()
    {
        if (!(@session_id() || @session_start())) {
            throw new GravityscanException('Unable to start session for local storage. ' . error_get_last(), 500);
        }
    }

    public function has($key)
    {
        return is_array($_SESSION) &&
        array_key_exists('gravityscan-agent', $_SESSION) &&
        is_array($_SESSION['gravityscan-agent']) &&
        array_key_exists($key, $_SESSION['gravityscan-agent']);
    }

    public function set($key, $value)
    {
        $_SESSION['gravityscan-agent'][$key] = $value;
    }

    public function get($key)
    {
        if ($this->has($key)) {
            return $_SESSION['gravityscan-agent'][$key];
        }
        return null;
    }

    public function delete($key)
    {
        unset($_SESSION['gravityscan-agent'][$key]);
    }

    public function destroy()
    {
        @session_destroy();
    }
}

//class GravityscanLocalStorageTemp implements GravityscanLocalStorage
//{
//
//}";s:32:"classes/GravityscanException.php";s:56:"<?php

class GravityscanException extends Exception
{

}";s:28:"classes/GravityscanAgent.php";s:3258:"<?php

class GravityscanAgent
{
    private $request;
    private $response;
    private $localStorage;

    /**
     * @param GravityscanRequest $request
     * @param GravityscanResponse $response
     */
    public function __construct($request, $response)
    {
        $this->request = $request;
        $this->response = $response;
    }

    /**
     * @return bool
     */
    public function verifySignature()
    {
        return true;
    }

    /**
     * @throws GravityscanException
     */
    public function run()
    {
        $body = $this->getRequest()->getBody();
        $jsonBody = @json_decode($body, true);
        if (!$jsonBody) {
            throw new GravityscanException('Error parsing the JSON body.', 422);
        }

        $commandName = !empty($jsonBody['command']) && is_string($jsonBody['command']) ? $jsonBody['command'] : null;
        $commandArgs = isset($jsonBody['args']) ? $jsonBody['args'] : null;
        $commandClass = 'Gravityscan' . $commandName . 'Command';

        if (!class_exists($commandClass)) {
            throw new GravityscanException('Command ' . $commandName . ' not found.', 422);
        }

        /** @var GravityscanCommand $command */
        $command = new $commandClass($this);
        $result = $command->setArgs($commandArgs)
            ->setRequest($this->getRequest())
            ->setResponse($this->getResponse())
            ->execute();

        if ($result) {
            $this->getResponse()
                ->setBody($result)
                ->send();
        }
    }

    /**
     * @return GravityscanRequest
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * @param GravityscanRequest $request
     * @return $this
     */
    public function setRequest($request)
    {
        $this->request = $request;
        return $this;
    }

    /**
     * @return GravityscanResponse
     */
    public function getResponse()
    {
        return $this->response;
    }

    /**
     * @param GravityscanResponse $response
     * @return $this
     */
    public function setResponse($response)
    {
        $this->response = $response;
        return $this;
    }

    /**
     * @return GravityscanLocalStorage
     * @throws GravityscanException
     */
    public function getLocalStorage()
    {
        if (!$this->localStorage) {
            $storageDrivers = array(
                'GravityscanLocalStorageSession',
                // 'GravityscanLocalStorageTemp',
            );
            foreach ($storageDrivers as $driver) {
                if (class_exists($driver)) {
                    /** @var GravityscanLocalStorage $storage */
                    $storage = new $driver();
                    try {
                        $storage->initialize();
                        $this->localStorage = $storage;
                    } catch (GravityscanException $e) {
                        continue;
                    }
                }
            }
        }
        if (!$this->localStorage) {
            if (isset($e)) {
                throw $e;
            }
            throw new GravityscanException('Unable to utilize local storage.', 500);
        }
        return $this->localStorage;
    }

}

";s:31:"classes/GravityscanResponse.php";s:5734:"<?php

class GravityscanResponse
{
    public static $statusTexts = array(
        100 => 'Continue',
        101 => 'Switching Protocols',
        102 => 'Processing',            // RFC2518
        200 => 'OK',
        201 => 'Created',
        202 => 'Accepted',
        203 => 'Non-Authoritative Information',
        204 => 'No Content',
        205 => 'Reset Content',
        206 => 'Partial Content',
        207 => 'Multi-Status',          // RFC4918
        208 => 'Already Reported',      // RFC5842
        226 => 'IM Used',               // RFC3229
        300 => 'Multiple Choices',
        301 => 'Moved Permanently',
        302 => 'Found',
        303 => 'See Other',
        304 => 'Not Modified',
        305 => 'Use Proxy',
        307 => 'Temporary Redirect',
        308 => 'Permanent Redirect',    // RFC7238
        400 => 'Bad Request',
        401 => 'Unauthorized',
        402 => 'Payment Required',
        403 => 'Forbidden',
        404 => 'Not Found',
        405 => 'Method Not Allowed',
        406 => 'Not Acceptable',
        407 => 'Proxy Authentication Required',
        408 => 'Request Timeout',
        409 => 'Conflict',
        410 => 'Gone',
        411 => 'Length Required',
        412 => 'Precondition Failed',
        413 => 'Payload Too Large',
        414 => 'URI Too Long',
        415 => 'Unsupported Media Type',
        416 => 'Range Not Satisfiable',
        417 => 'Expectation Failed',
        418 => 'I\'m a teapot',                                               // RFC2324
        421 => 'Misdirected Request',                                         // RFC7540
        422 => 'Unprocessable Entity',                                        // RFC4918
        423 => 'Locked',                                                      // RFC4918
        424 => 'Failed Dependency',                                           // RFC4918
        425 => 'Reserved for WebDAV advanced collections expired proposal',   // RFC2817
        426 => 'Upgrade Required',                                            // RFC2817
        428 => 'Precondition Required',                                       // RFC6585
        429 => 'Too Many Requests',                                           // RFC6585
        431 => 'Request Header Fields Too Large',                             // RFC6585
        451 => 'Unavailable For Legal Reasons',                               // RFC7725
        500 => 'Internal Server Error',
        501 => 'Not Implemented',
        502 => 'Bad Gateway',
        503 => 'Service Unavailable',
        504 => 'Gateway Timeout',
        505 => 'HTTP Version Not Supported',
        506 => 'Variant Also Negotiates (Experimental)',                      // RFC2295
        507 => 'Insufficient Storage',                                        // RFC4918
        508 => 'Loop Detected',                                               // RFC5842
        510 => 'Not Extended',                                                // RFC2774
        511 => 'Network Authentication Required',                             // RFC6585
    );

    private $statusCode = 200;
    private $body = '';
    private $headers = array();


    public function __construct()
    {

    }

    /**
     *
     */
    public function send()
    {
        $this->sendHeaders();
        echo $this->getBody();
        exit;
    }

    /**
     * @param string $message
     */
    public function sendStreamMessage($message)
    {
        $this->sendHeaders();
        echo $message . "\x00";
        flush();
    }

    /**
     * @return bool
     */
    public function sendHeaders()
    {
        if (headers_sent()) {
            return false;
        }

        $statusCode = $this->getStatusCode();
        if ($statusCode !== null) {
            header(sprintf('HTTP/1.0 %s %s',
                $statusCode,
                array_key_exists($statusCode, self::$statusTexts) ? self::$statusTexts[$statusCode] : 'Unknown status'
            ), true, $statusCode);
        }

        $headers = $this->getHeaders();
        if (is_array($headers)) {
            foreach ($headers as $header => $value) {
                if (is_numeric($header)) {
                    header($value);
                } else {
                    header("$header: $value");
                }
            }
        }

        return true;
    }

    /**
     * @param mixed $statusCode
     * @return GravityscanResponse
     */
    public function setStatusCode($statusCode)
    {
        $this->statusCode = $statusCode;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getStatusCode()
    {
        return $this->statusCode;
    }

    /**
     * @param $body
     * @return GravityscanResponse
     */
    public function setJson($body)
    {
        return $this->setHeader('Content-Type', 'application/json')
            ->setBody(json_encode($body));
    }

    /**
     * @param mixed $body
     * @return GravityscanResponse
     */
    public function setBody($body)
    {
        $this->body = $body;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getBody()
    {
        return $this->body;
    }

    /**
     * @param $header
     * @param $value
     * @return GravityscanResponse
     */
    public function setHeader($header, $value)
    {
        $this->headers[$header] = $value;
        return $this;
    }

    /**
     * @param mixed $headers
     * @return GravityscanResponse
     */
    public function setHeaders($headers)
    {
        $this->headers = $headers;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getHeaders()
    {
        return $this->headers;
    }

}";s:51:"classes/commands/GravityscanPatternMatchCommand.php";s:2709:"<?php

class GravityscanPatternMatchCommand extends GravityscanCommand
{

    public function getPipedArguments()
    {
        return array(
            'fileList',
        );
    }

    public function execute()
    {
        $regexList = $this->getArg('regexList');
        if (!is_array($regexList)) {
            throw new GravityscanException('Invalid [regexList] argument supplied', 422);
        }

        $fileList = $this->getArg('fileList');
        if (!is_array($regexList)) {
            throw new GravityscanException('Invalid [fileList] argument supplied', 422);
        }

        $matchingPattern = $this->getArg('matchingPattern');
        $readLength = $this->getArg('readLength');

        $this->startCommandStream();
        foreach ($fileList as $file) {
            try {
                $filePath = $this->validateFile($file);
            } catch (GravityscanException $e) {
                continue;
            }
            if (!$matchingPattern || preg_match($matchingPattern, $filePath)) {
                $result = $this->scanFile($filePath, $regexList, $readLength);
                if ($result) {
                    list($pattern, $matchString) = $result;
                    $this->writeCommandStream(json_encode(array(
                        $file,
                        $pattern,
                        base64_encode($matchString),
                    )));
                }
            }
        }
        $this->endCommandStream();
    }

    /**
     * @param string $file
     * @param array $patterns
     * @param null $readLength
     * @return array|bool
     */
    protected function scanFile($file, $patterns, $readLength = null)
    {
        $fh = @fopen($file, 'r');
        if (!$fh) {
            return false;
        }
        $totalRead = 0;
        $maxReadLength = is_int($readLength) && $readLength > 0 ? $readLength : 50 * 1024 * 1024;
        $match = false;

        while (!feof($fh)) {
            $length = min(1 * 1024 * 1024, $maxReadLength);

            $data = fread($fh, $length); // read 1 megs max per chunk
            $bytesRead = GravityscanUtils::strlen($data);
            $totalRead += $bytesRead;
            $maxReadLength -= $bytesRead;
            if ($totalRead < 1) {
                break;
            }

            foreach ($patterns as $pattern) {
                if (preg_match($pattern, $data, $matches)) {
                    $matchString = $matches[0];
                    $match = array($pattern, $matchString);
                    break;
                }
            }

            if ($maxReadLength <= 0) {
                break;
            }
        }
        fclose($fh);
        return $match;
    }
}";s:54:"classes/commands/GravityscanListDirectoriesCommand.php";s:1484:"<?php

class GravityscanListDirectoriesCommand extends GravityscanCommand
{

    public function execute()
    {
        $directory = $this->getArg('directory');
        if (!is_string($directory)) {
            throw new GravityscanException('Invalid [directory] argument supplied', 422);
        }
        $directory = $this->validateFile($directory);

        $max = $this->getArg('max', 10000);
        if (!is_numeric($max)) {
            throw new GravityscanException('Invalid [max] argument supplied', 422);
        }
        $max = abs(intval($max));

        $offset = $this->getArg('offset', 0);
        if (!is_numeric($offset)) {
            throw new GravityscanException('Invalid [offset] argument supplied', 422);
        }
        $offset = abs(intval($offset));

        $this->startCommandStream();
        $count = 0;
        if (is_dir($directory)) {
            $directoryIterator = new DirectoryIterator($directory);
            $directoryIterator->seek($offset);
            while ($directoryIterator->valid()) {
                $file = $directoryIterator->current();
                if (!$file->isDot() && !$file->isLink() && $file->isDir()) {
                    $this->writeCommandStream($file->key() . ':' . $file->getFilename());
                    if (++$count >= $max) {
                        break;
                    }
                }
                $directoryIterator->next();
            }
        }
        $this->endCommandStream();
    }
}";s:43:"classes/commands/GravityscanInfoCommand.php";s:272:"<?php

class GravityscanInfoCommand extends GravityscanCommand
{

    public function execute()
    {
        $this->getResponse()
            ->setHeader('Content-Type', 'text/plain')
            ->sendHeaders();
        ob_start('strip_tags');
        phpinfo();
    }
}";s:46:"classes/commands/GravityscanVersionCommand.php";s:264:"<?php

class GravityscanVersionCommand extends GravityscanCommand
{

    public function execute()
    {
        $this->getResponse()
            ->setJson(array(
                'version' => GRAVITYSCAN_AGENT_VERSION,
            ))
            ->send();

    }
}";s:51:"classes/commands/GravityscanLocalStorageCommand.php";s:1659:"<?php

class GravityscanLocalStorageCommand extends GravityscanCommand
{

    public function execute()
    {
        $action = $this->getArg('action');
        if (!is_string($action)) {
            throw new GravityscanException('Invalid [action] argument supplied', 422);
        }

        $key = $this->getArg('key');
        $value = $this->getArg('value', null);

        $storage = $this->getAgent()->getLocalStorage();

        switch ($action) {
            case 'set':
            case 'get':
            case 'delete':
                if (!is_string($key)) {
                    throw new GravityscanException('Invalid [key] argument supplied', 422);
                }
                break;
        }

        switch ($action) {
            case 'set':
                $storage->set($key, $value);
                break;

            case 'get':
                if ($storage->has($key)) {
                    $this->getResponse()
                        ->setJson(array(
                            'value' => $storage->get($key),
                        ))
                        ->send();
                }
                throw new GravityscanException('LocalStorage [' . $key . '] not found.', 422);

            case 'delete':
                $storage->delete($key);
                break;

            case 'destroy':
                $storage->destroy();
                break;

            default:
                throw new GravityscanException('Invalid [action] argument supplied', 422);
        }

        $this->getResponse()
            ->setJson(array(
                'success' => true,
            ))
            ->send();
    }
}";s:48:"classes/commands/GravityscanListFilesCommand.php";s:1480:"<?php

class GravityscanListFilesCommand extends GravityscanCommand
{

    public function execute()
    {
        $directory = $this->getArg('directory');
        if (!is_string($directory)) {
            throw new GravityscanException('Invalid [directory] argument supplied', 422);
        }
        $directory = $this->validateFile($directory);

        $max = $this->getArg('max', 10000);
        if (!is_numeric($max)) {
            throw new GravityscanException('Invalid [max] argument supplied', 422);
        }
        $max = abs(intval($max));

        $offset = $this->getArg('offset', 0);
        if (!is_numeric($offset)) {
            throw new GravityscanException('Invalid [offset] argument supplied', 422);
        }
        $offset = abs(intval($offset));

        $this->startCommandStream();
        $count = 0;
        if (is_dir($directory)) {
            $directoryIterator = new DirectoryIterator($directory);
            $directoryIterator->seek($offset);
            while ($directoryIterator->valid()) {
                $file = $directoryIterator->current();
                if (!$file->isDot() && !$file->isLink() && $file->isFile()) {
                    $this->writeCommandStream($file->key() . ':' . $file->getFilename());
                    if (++$count >= $max) {
                        break;
                    }
                }
                $directoryIterator->next();
            }
        }
        $this->endCommandStream();

    }
}";s:45:"classes/commands/GravityscanUpdateCommand.php";s:1102:"<?php

class GravityscanUpdateCommand extends GravityscanCommand
{

    public function execute()
    {
        // Check for JWT
        $jwt = $this->getArg('jwt');
        if (!$jwt) {
            throw new GravityscanException('Invalid [jwt] argument supplied.', 422);
        }

        // Test if writable
        if (!GRAVITYSCAN_AGENT_IS_WRITABLE) {
            throw new GravityscanException('Agent is not writable.', 422);
        }

        // Call Gravity API to download new build
        $build = file_get_contents(sprintf(gsConfig('update_api_url'), rawurlencode(gsConfig('site_id')), rawurlencode($jwt)));

        // TODO: Add a checksum here.
        if (is_string($build) && GravityscanUtils::strlen($build) > 0) {
            // Install new build
            file_put_contents(GRAVITYSCAN_AGENT_FILE, $build);
            $this->getResponse()
                ->setJson(array(
                    'success' => true,
                ))
                ->send();
        } else {
            throw new GravityscanException('Output from API was not a Phar file.', 422);
        }
    }
}";s:50:"classes/commands/GravityscanMalwareScanCommand.php";s:3896:"<?php

class GravityscanMalwareScanCommand extends GravityscanCommand
{

    public function getPipedArguments()
    {
        return array(
            'fileList',
        );
    }

    public function execute()
    {
        $regexList = $this->getArg('regexList');
        if (!is_array($regexList)) {
            throw new GravityscanException('Invalid [regexList] argument supplied', 422);
        }

        $fileList = $this->getArg('fileList');
        if (!is_array($regexList)) {
            throw new GravityscanException('Invalid [fileList] argument supplied', 422);
        }

        $matchingPattern = $this->getArg('matchingPattern');
        $readLength = $this->getArg('readLength');

        $this->startCommandStream();
        foreach ($fileList as $file) {
            try {
                $filePath = $this->validateFile($file);
            } catch (GravityscanException $e) {
                continue;
            }
            if (!$matchingPattern || preg_match($matchingPattern, $filePath)) {
                $result = $this->scanFileForMalware($filePath, $regexList, $readLength);
                if ($result) {
                    list($key, $matchString, $beforeString, $afterString, $hash) = $result;
                    $this->writeCommandStream(json_encode(array(
                        $file,
                        $key,
                        base64_encode($matchString),
                        base64_encode($beforeString),
                        base64_encode($afterString),
                        base64_encode($hash),
                    )));
                }
            }
        }
        $this->endCommandStream();
    }

    /**
     * @param string $file
     * @param array $signatures
     * @param null $readLength
     * @return array|bool
     */
    protected function scanFileForMalware($file, $signatures, $readLength = null)
    {
        $fh = @fopen($file, 'r');
        if (!$fh) {
            return false;
        }
        $totalRead = 0;
        $maxReadLength = is_int($readLength) && $readLength > 0 ? $readLength : 50 * 1024 * 1024;
        $match = false;

        while (!feof($fh)) {
            $length = min(1 * 1024 * 1024, $maxReadLength);
            $data = fread($fh, $length); // read 1 megs max per chunk
            $bytesRead = GravityscanUtils::strlen($data);
            $totalRead += $bytesRead;
            $maxReadLength -= $bytesRead;
            if ($totalRead < 1) {
                break;
            }

            foreach ($signatures as $rule) {
                list($key, , $signature, , $type) = $rule;
                if ($type === 'browser') {
                    continue;
                }
                if (preg_match('/(' . $signature . ')/i', $data, $matches, PREG_OFFSET_CAPTURE)) {
                    $matchString = $matches[1][0];
                    $matchOffset = $matches[1][1];
                    $beforeString = GravityscanUtils::substr($data, max(0, $matchOffset - 100), $matchOffset - max(0, $matchOffset - 100));
                    $afterString = GravityscanUtils::substr($data, $matchOffset + GravityscanUtils::strlen($matchString), 100);
                    $match = array($key, $matchString, $beforeString, $afterString);
                    break;
                }
            }

            if ($maxReadLength <= 0) {
                break;
            }
        }
        if ($match) {
            fseek($fh, 0, SEEK_SET);

            $sha256Context = hash_init('sha256');
            while (!feof($fh)) {
                $data = fread($fh, 65536);
                if ($data === false) {
                    break;
                }
                hash_update($sha256Context, str_replace(array("\n", "\r", "\t", " "), "", $data));
            }
            $match[] = hash_final($sha256Context, true);
        }
        fclose($fh);
        return $match;
    }
}";s:48:"classes/commands/GravityscanMulticallCommand.php";s:3205:"<?php

class GravityscanMulticallCommand extends GravityscanCommand
{

    private $pipes;

    public function execute()
    {
        $commands = $this->getArgs();
        if (!is_array($commands)) {
            throw new GravityscanException('Invalid [commands] argument supplied', 422);
        }
        foreach ($commands as $index => $commandArray) {
            if (!is_array($commandArray) || !isset($commandArray['command'])) {
                throw new GravityscanException('Invalid [commands] argument supplied', 422);
            }
            $commandName = $commandArray['command'];
            $commandClass = 'Gravityscan' . $commandName . 'Command';

            if (!class_exists($commandClass)) {
                throw new GravityscanException('Command ' . $commandName . ' not found.', 422);
            }
            $commands[$index]['class'] = $commandClass;
        }

        $this->pipes = array();
        foreach ($commands as $commandArray) {
            // $command = $commandArray['command'];
            $args = isset($commandArray['args']) && is_array($commandArray['args']) ? $commandArray['args'] : array();
            $pipe = isset($commandArray['pipe']) && is_string($commandArray['pipe']) ? $commandArray['pipe'] : null;
            $commandClass = $commandArray['class'];

            if ($pipe) {
                $response = $this->pipes[$pipe] = new GravityscanMulticallCommandResponse();
            } else {
                $response = $this->getResponse();
            }

            /** @var GravityscanCommand $command */
            $command = new $commandClass($this->getAgent());

            foreach ($command->getPipedArguments() as $pipedArgument) {
                if (isset($args[$pipedArgument]) &&
                    is_string($args[$pipedArgument]) &&
                    strpos($args[$pipedArgument], '@') === 0
                ) {
                    $pipedArgumentName = substr($args[$pipedArgument], 1);
                    if (isset($this->pipes[$pipedArgumentName])) {
                        $args[$pipedArgument] = $this->pipes[$pipedArgumentName]->getResponseArray();
                    }
                }
            }

            /** @var GravityscanCommand $command */
            $result = $command->setArgs($args)
                ->setRequest($this->getRequest())
                ->setResponse($response)
                ->execute();

            if ($result) {
                $command->startCommandStream()
                    ->writeCommandStream($result)
                    ->endCommandStream();
            }
        }
    }
}

class GravityscanMulticallCommandResponse extends GravityscanResponse
{
    private $responseArray;

    /**
     * @param string $message
     */
    public function sendStreamMessage($message)
    {
        $this->sendHeaders();
        echo $message . "\x00";
        flush();
        if (preg_match('/^\\d+:/', $message)) {
            list(, $message) = explode(':', $message, 2);
        }
        $this->responseArray[] = $message;
    }

    /**
     * @return mixed
     */
    public function getResponseArray()
    {
        return array_slice($this->responseArray, 1, -1);
    }


}";s:39:"classes/commands/GravityscanCommand.php";s:4728:"<?php

abstract class GravityscanCommand
{
    /** @var GravityscanAgent */
    private $agent;

    abstract public function execute();

    /**
     * @var array
     */
    private $args;

    private $request;
    /**
     * @var GravityscanResponse
     */
    private $response;

    private $streamBoundary;

    /**
     * @param GravityscanAgent $agent
     * @param array $args
     * @param GravityscanRequest $request
     * @param GravityscanResponse $response
     */
    public function __construct($agent, $args = null, $request = null, $response = null)
    {
        $this->agent = $agent;
        $this->args = $args;
        $this->request = $request;
        $this->response = $response;
    }

    /**
     * Returns an array of argument params that can be piped in a multicall request.
     *
     * @return array
     */
    public function getPipedArguments()
    {
        return array();
    }

    /**
     * @return GravityscanCommand
     */
    public function startCommandStream()
    {
        return $this->writeCommandStream('cmd_start:' . $this->getCommandName() . ':' . $this->getStreamBoundary());
    }

    /**
     * @param string $message
     * @return $this
     */
    public function writeCommandStream($message)
    {
        $this->getResponse()->sendStreamMessage($message);
        return $this;
    }

    /**
     * @return GravityscanCommand
     */
    public function endCommandStream()
    {
        return $this->writeCommandStream('cmd_end:' . $this->getCommandName() . ':' . $this->getStreamBoundary());
    }

    /**
     * @return string
     */
    public function getCommandName()
    {
        if (preg_match('/^Gravityscan(.*?)Command$/i', get_class($this), $matches)) {
            return $matches[1];
        }
        return get_class($this);
    }

    /**
     * @return mixed
     */
    public function getStreamBoundary()
    {
        if (!$this->streamBoundary) {
            $this->streamBoundary = GravityscanUtils::getRandomString(32, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789');
        }
        return $this->streamBoundary;
    }

    /**
     * @param string $file
     * @return string
     * @throws GravityscanException
     */
    public function validateFile($file)
    {
        $file = $this->getRequest()->getDocumentRoot() . DIRECTORY_SEPARATOR . ltrim($file, '/\\');
        if (!is_dir($file) && !is_file($file)) {
            throw new GravityscanException('File is not readable.', 422);
        }
        $file = realpath($file);
        if (!$file) {
            throw new GravityscanException('Error resolving canonicalized absolute pathname for ' . $file . '.', 422);
        }
//        if (strpos($file, $this->getRequest()->getDocumentRoot()) !== 0) {
//            throw new GravityscanException('File is outside the document root.', 422);
//        }
        return $file;
    }

    /**
     * @param array $args
     * @return GravityscanCommand
     */
    public function setArgs($args)
    {
        $this->args = $args;
        return $this;
    }

    /**
     * @return array
     */
    public function getArgs()
    {
        return $this->args;
    }

    /**
     * @param string $name
     * @param null $default
     * @return mixed|null
     */
    public function getArg($name, $default = null)
    {
        if (is_array($this->args) && array_key_exists($name, $this->args)) {
            $sessionPrefix = '$localStorage.';
            if (is_string($this->args[$name]) && strpos($this->args[$name], $sessionPrefix) !== false) {
                $sessionKey = substr($this->args[$name], strlen($sessionPrefix));
                $storage = $this->getAgent()->getLocalStorage();
                if ($storage->has($sessionKey)) {
                    return $storage->get($sessionKey);
                }
            }
            return $this->args[$name];
        }
        return $default;
    }

    /**
     * @param GravityscanRequest $request
     * @return GravityscanCommand
     */
    public function setRequest($request)
    {
        $this->request = $request;
        return $this;
    }

    /**
     * @return GravityscanRequest
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * @param GravityscanResponse $response
     * @return GravityscanCommand
     */
    public function setResponse($response)
    {
        $this->response = $response;
        return $this;
    }

    /**
     * @return GravityscanResponse
     */
    public function getResponse()
    {
        return $this->response;
    }

    /**
     * @return GravityscanAgent
     */
    public function getAgent()
    {
        return $this->agent;
    }
}";s:30:"classes/GravityscanRequest.php";s:2311:"<?php

class GravityscanRequest
{
    private $body;
    private $headers;
    private $method;
    private $documentRoot;

    /**
     *
     */
    public static function createFromGlobals()
    {
        $request = new self();
        $headers = array();
        foreach ($_SERVER as $key => $value) {
            if (strpos($key, 'HTTP_') === 0) {
                $header = str_replace(' ', '-', ucwords(str_replace('_', ' ', strtolower(substr($key, 5)))));
                $headers[$header] = $value;
            }
        }
        $request->setHeaders($headers)
            ->setBody(file_get_contents('php://input'))
            ->setMethod(isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : 'GET')
            ->setDocumentRoot(isset($_SERVER['DOCUMENT_ROOT']) ? realpath($_SERVER['DOCUMENT_ROOT']) : GRAVITYSCAN_AGENT_FC_PATH);

        return $request;
    }

    /**
     * @param mixed $body
     * @return GravityscanRequest
     */
    public function setBody($body)
    {
        $this->body = $body;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getBody()
    {
        return $this->body;
    }

    /**
     * @param mixed $headers
     * @return GravityscanRequest
     */
    public function setHeaders($headers)
    {
        $this->headers = $headers;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getHeaders()
    {
        return $this->headers;
    }

    /**
     * @param $header
     * @return mixed
     */
    public function getHeader($header)
    {
        return array_key_exists($header, $this->headers) ? $this->headers[$header] : null;
    }

    /**
     * @param mixed $method
     * @return GravityscanRequest
     */
    public function setMethod($method)
    {
        $this->method = $method;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getMethod()
    {
        return $this->method;
    }

    /**
     * @param mixed $documentRoot
     * @return GravityscanRequest
     */
    public function setDocumentRoot($documentRoot)
    {
        $this->documentRoot = $documentRoot;
        return $this;
    }

    /**
     * @return mixed
     */
    public function getDocumentRoot()
    {
        return $this->documentRoot;
    }
}";s:15:"diagnostics.php";s:6400:"<?php ob_start(); ?>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <META NAME="ROBOTS" CONTENT="NOINDEX, NOFOLLOW">

    <title>Gravityscan Accelerator</title>

    <style type="text/css">
        body {
            width: 42em;
            margin: 0 auto;
            font-family: sans-serif;
            background: #fff;
            font-size: 1em;
        }

        h1 {
            letter-spacing: -0.04em;
            margin: 1em 0px .5em;
        }

        h1 + p {
            margin: 0 0 2em;
            color: #333;
            font-size: 90%;
            font-style: italic;
        }

        code {
            font-family: monaco, monospace;
        }

        a {
            color: #1e6fc0;
        }

        a:hover {
            color: #2695ff;
        }

        #results {
            margin: 0.8em 0px;
            font-size: 1.5em;
        }

        #results div.pass,
        #results div.warn,
        #results div.fail {
            color: #fff;
            margin: 20px 0px;
            padding: 20px;
        }

        #results div.pass {
            background: #191;

        }

        #results div.fail {
            background: #911;
        }

        #results div.warn {
            background: #e59c00;
        }

        #results table {
            border-collapse: collapse;
            width: 100%;
            margin: 20px 0px;
        }

        #results table th,
        #results table td {
            padding: 0.4em;
            text-align: left;
            vertical-align: top;
            border: 1px solid #c9c9c9;
        }

        #results table th {
            width: 12em;
            font-weight: normal;
        }

        #results table thead th {
            border-color: #333333;
            background-color: #333333;
            color: #fff;
            font-weight: bold;
        }

        #results table.errors thead th {
            background-color: #911;
            border-color: #911;
        }

        #results table.warnings thead th {
            background-color: #e59c00;
            border-color: #e59c00;
        }

        #results table tbody tr:nth-child(odd) {
            background: #eee;
        }

        #results table td.pass {
            color: #191;
        }

        #results table td.fail {
            color: #911;
        }

        #results table td.warn {
            color: #b9822a;
        }

    </style>
</head>
<body>

<h1>Gravityscan Accelerator Diagnostics</h1>

<p>You are currently running Gravityscan Accelerator version <strong><?php echo GRAVITYSCAN_AGENT_VERSION ?></strong>.
</p>

<?php
$compatibilityChecks = array(
    array(
        'test'  => version_compare(PHP_VERSION, '5.3.3', '>='),
        'title' => 'PHP Version',
        'error' => 'Gravityscan Accelerator requires PHP 5.3.3 or newer, this version is ' . PHP_VERSION . '.',
    ),
    array(
        'test'  => function_exists('openssl_verify'),
        'title' => 'OpenSSL',
        'error' => 'PHP <a href="http://www.php.net/openssl">OpenSSL</a> is either not loaded or not compiled in.',
    ),
    array(
        'test'  => @preg_match('/^.$/u', 'ñ'),
        'title' => 'PCRE UTF-8',
        'error' => '<a href="http://php.net/pcre">PCRE</a> has not been compiled with UTF-8 support.',
    ),
    array(
        'test'  => @preg_match('/^\pL$/u', 'ñ'),
        'title' => 'PCRE UTF-8',
        'error' => '<a href="http://php.net/pcre">PCRE</a> has not been compiled with Unicode property support.',
    ),
    array(
        'test'  => !extension_loaded('mbstring') || !(ini_get('mbstring.func_overload') & MB_OVERLOAD_STRING),
        'title' => 'Mbstring Overloaded',
        'error' => 'The <a href="http://php.net/mbstring">mbstring</a> extension is overloading PHP\'s native string functions.',
    ),
);

$warningChecks = array(
    array(
        'test'  => GRAVITYSCAN_AGENT_IS_WRITABLE,
        'title' => 'Accelerator File Permissions',
        'error' => 'The Accelerator file is not writable. Automatic updates are disabled.',
    ),
);

$failed = false;
$errors = array();
foreach ($compatibilityChecks as $check) {
    if (!$check['test']) {
        $failed = true;
        $errors[] = $check;
    }
}

$warning = false;
$warnings = array();
foreach ($warningChecks as $check) {
    if (!$check['test']) {
        $warning = true;
        $warnings[] = $check;
    }
}

?>

<div id="results">
    <?php if ($failed || $warning): ?>
        <?php if ($failed): ?>
            <div class="fail">
                ✘ Gravityscan Accelerator may not work correctly with your environment.
            </div>
        <?php else: ?>
            <div class="warn">
                (<strong>!</strong>) Gravityscan Accelerator will function correctly, but some optional features may be
                disabled.
            </div>
        <?php endif ?>
        <?php if ($failed): ?>
            <table cellpadding="0" cellspacing="0" class="errors">
                <thead>
                <tr>
                    <th colspan="2">Errors:</th>
                </tr>
                </thead>
                <tbody>
                <?php foreach ($errors as $error): ?>
                    <tr>
                        <th><?php echo $error['title'] ?></th>
                        <td class="fail"><?php echo $error['error'] ?></td>
                    </tr>
                <?php endforeach ?>
                </tbody>
            </table>
        <?php endif ?>
        <?php if ($warning): ?>
            <table cellpadding="0" cellspacing="0" class="warnings">
                <thead>
                <tr>
                    <th colspan="2">Warnings:</th>
                </tr>
                </thead>
                <tbody>
                <?php foreach ($warnings as $error): ?>
                    <tr>
                        <th><?php echo $error['title'] ?></th>
                        <td class="warn"><?php echo $error['error'] ?></td>
                    </tr>
                <?php endforeach ?>
                </tbody>
            </table>
        <?php endif ?>

    <?php else: ?>
        <div class="pass">✔ Your environment passed all requirements.</div>
    <?php endif ?>
</div>

<h1>Public Key</h1>

<pre><?php echo gsConfig('public_key') ?></pre>

</body>
</html>
<?php return ob_get_clean(); ?>
";s:8:"init.php";s:2177:"<?php

define('GRAVITYSCAN_AGENT_VERSION', '0.0.7');
!defined('GRAVITYSCAN_AGENT_FILE') && define('GRAVITYSCAN_AGENT_FILE', __FILE__);
!defined('GRAVITYSCAN_AGENT_IS_WRITABLE') && define('GRAVITYSCAN_AGENT_IS_WRITABLE', is_writable(__FILE__));
define('GRAVITYSCAN_AGENT_FC_PATH', dirname(__FILE__));
define('GRAVITYSCAN_AGENT_CLASS_PATH', GRAVITYSCAN_AGENT_FC_PATH . '/classes');

if (!function_exists('gsIncludeFile')) {
    function gsIncludeFile($file, $once = false)
    {
        if ($once) {
            return include_once GRAVITYSCAN_AGENT_FC_PATH . '/' . $file;
        } else {
            return include GRAVITYSCAN_AGENT_FC_PATH . '/' . $file;
        }
    }
}
if (!function_exists('gsRequireFile')) {
    function gsRequireFile($file, $once = true)
    {
        if ($once) {
            return require_once GRAVITYSCAN_AGENT_FC_PATH . '/' . $file;
        } else {
            return require GRAVITYSCAN_AGENT_FC_PATH . '/' . $file;
        }
    }
}

function gsConfig($key)
{
    static $config;
    if (!isset($config)) {
        $config = gsRequireFile('config.php');
    }
    return array_key_exists($key, $config) ? $config[$key] : null;
}


gsRequireFile('classes/GravityscanAgent.php');
gsRequireFile('classes/GravityscanAgentAuth.php');
gsRequireFile('classes/GravityscanRequest.php');
gsRequireFile('classes/GravityscanResponse.php');
gsRequireFile('classes/GravityscanException.php');
gsRequireFile('classes/GravityscanUtils.php');
gsRequireFile('classes/GravityscanLocalStorage.php');
gsRequireFile('classes/commands/GravityscanCommand.php');
gsRequireFile('classes/commands/GravityscanInfoCommand.php');
gsRequireFile('classes/commands/GravityscanUpdateCommand.php');
gsRequireFile('classes/commands/GravityscanVersionCommand.php');
gsRequireFile('classes/commands/GravityscanListDirectoriesCommand.php');
gsRequireFile('classes/commands/GravityscanListFilesCommand.php');
gsRequireFile('classes/commands/GravityscanMalwareScanCommand.php');
gsRequireFile('classes/commands/GravityscanPatternMatchCommand.php');
gsRequireFile('classes/commands/GravityscanMulticallCommand.php');
gsRequireFile('classes/commands/GravityscanLocalStorageCommand.php');";s:10:"config.php";s:958:"<?php

return array (
  'public_key' => '-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA8KnL1pHEnIMQbqmuDCjS
8nKPcjXVzbtwAbc32kQMwmDOxUicI66F6ZuT9sEmv+izHJ8Q8cxvQXUU2zYHtgoS
IXHnN+aURhQP8cRPQwodViDGgTfV+R2b4TyPNrRmVSCltFddECr8Wh1Rs3vb6uwI
VwgMZhX+pU41yCK3/QjI9PDfnT+hB3yApejxY3fyEwdBJzwtnNWqJRa3NlS7qqM6
Chsvi/vl9dXzE/6Yw7h4LYTPNSAnZLRw+viEM28KXDMl/q02G4PWPqElxKisnYXz
nfGo03zTSipTnjYBD91/Hnb++d/LiGsHBsB48ZvvitaHHD840+wUWAHXBcct4LAY
RzaGoBMDRT8pIeFz3vLvEERZfFMtj6Vg1PSPPgGPG8BsHPay+0OlC+Yyzp+z2AQ5
fg2yHgfkk+jfaDTXqzPmqrilzNZHCLNEDVVSp+VVdC1tUITNSEAH1qZv2kni2Z4c
KUBiGwIsv1VgEGmtrAKGReKf0l59GDYfapn0YzTo38PJMno8y5LpuxbqC8VV8YaI
aaCn/wNfz/wKOi9nB7Jo46F2yGTgEupzx89x+Y2+J49Ngm7I/GV9EUk9XCc+km83
v92Rp3GrCK0kJC8PU7s87rVXywZ4tQrj21ZgQsUQhi/Kptha1jIstDWL6NcN8hyS
Kp4UBiIk4eQLz5/tA7dhaxkCAwEAAQ==
-----END PUBLIC KEY-----
',
  'site_id' => 72534,
  'update_api_url' => 'https://www.gravityscan.com/api/sites/%d/download-agent?token=%s',
);";}')); ?>