proxy.php

<?
 
namespace Bitrix\Main\UI\ImageEditor;
 
use Bitrix\Main\Application;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Web\Uri;
use Bitrix\Main\Web\HttpClient;
 
class Proxy
{
    protected $uri;
 
    protected $allowedHosts = [];
 
    public function __construct($url, $allowedHosts = [])
    {
        $response = static::getResponse();
 
        if (!static::isAuthorized())
        {
            $response->setStatus(401)->flush();
            die('Unauthorized');
        }
 
        if (is_array($allowedHosts))
        {
            $this->allowedHosts = array_filter($allowedHosts, function($item) {
                return is_string($item) && !empty($item);
            });
        }
 
        $this->uri = new Uri($url);
 
        if (!$this->uri->getHost())
        {
            $this->uri->setHost(static::getCurrentHttpHost());
        }
    }
 
    protected static function getResponse()
    {
        return Application::getInstance()->getContext()->getResponse();
    }
 
    protected static function isAuthorized()
    {
        global $USER;
        return ($USER->isAuthorized() && check_bitrix_sessid());
    }
 
    protected function getCurrentHttpHost()
    {
        static $server = null;
 
        if ($server === null)
        {
            $server = Application::getInstance()->getContext()->getServer();
        }
 
        return explode(':', $server->getHttpHost())[0];
    }
 
    protected function getAllowedHosts()
    {
        return array_merge(
            [$this->getCurrentHttpHost()],
            $this->allowedHosts,
            $this->getUserAllowedHosts()
        );
    }
 
    protected function getUserAllowedHosts()
    {
        static $hosts = null;
 
        if ($hosts === null)
        {
            $hosts = Option::get('main', 'imageeditor_proxy_white_list', []);
            if (is_string($hosts))
            {
                $hosts = unserialize($hosts, ['allowed_classes' => false]);
            }
        }
 
        return $hosts;
    }
 
    protected function isAllowedHost($host)
    {
        return (
            in_array($host, $this->getAllowedHosts()) ||
            (in_array('*', $this->getAllowedHosts()) && $this->isEnabledForAll())
        );
    }
 
 
    protected function isEnabledForAll()
    {
        return static::getEnabledOption() === 'Y';
    }
 
    protected static function isEnabledForWhiteList()
    {
        return static::getEnabledOption() === 'YWL';
    }
 
    protected static function getEnabledOption()
    {
        static $option = null;
 
        if ($option === null)
        {
            $option = Option::get('main', 'imageeditor_proxy_enabled', 'N');
        }
 
        return $option;
    }
 
    protected function isEnabledForHost($host)
    {
        return static::isEnabledForWhiteList() && $this->isAllowedHost($host);
    }
 
    public function output()
    {
        $remoteHost = $this->uri->getHost();
        $currentHost = static::getCurrentHttpHost();
        $response = static::getResponse();
 
        if ($this->isEnabledForAll() ||
            $this->isEnabledForHost($remoteHost) ||
            $remoteHost === $currentHost)
        {
            $client = new HttpClient();
 
            //prevents proxy to LAN
            $client->setPrivateIp(false);
 
            $contents = $client->get($this->uri->getUri());
            if($contents !== false)
            {
                $response->addHeader('Content-Type', $client->getContentType());
                $response->flush($contents);
                return;
            }
        }
        $response->setStatus(404)->flush();
    }
}