SecurityHeaderMiddleware::getReportToHeader() - Code Metrics - Inspection of "Merge pull request #1 from signify-nz/fix/sigmas-1..." - signify-nz/silverstripe-security-headers - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( afecc8...a1ff37 )

by Guy
created 2021-03-12 02:39 UTC
SecurityHeaderMiddleware::getReportToHeader() A

↳ Parent: SecurityHeaderMiddleware
Complexity

Conditions	1
Paths	1
Size

Total Lines	11
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	7
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	11
rs	10
<?php

namespace Signify\Middleware;

use Signify\Extensions\SecurityHeaderSiteconfigExtension;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\Middleware\HTTPMiddleware;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Dev\TestOnly;
use SilverStripe\ORM\DB;
use SilverStripe\ORM\DataObject;
use SilverStripe\SiteConfig\SiteConfig;

class SecurityHeaderMiddleware implements HTTPMiddleware
{
    use Configurable;
    use Extensible;

    /**
     * An array of HTTP headers.
     * @config
     * @var array
     */
    private static $headers = [

        'global' => array(),
    ];

    /**
     * Whether to automatically add the CMS report endpoint to the CSP config.
     * @config
     * @var string
     */
    private static $enable_reporting = true;


    /**
     * The URI to report CSP violations to.
     * See routes.yml
     * @config
     * @var string
     */
    private static $report_uri = 'cspviolations/report';


    /**
     * Whether to use the report-to header and CSP directive.
     * @config
     * @var string
     */
    private static $use_report_to = false;


    /**
     * Whether subdomains should report to the same endpoint.
     * @config
     * @var string
     */
    private static $report_to_subdomains = false;


    /**
     * The group name for the report-to CSP directive.
     * @config
     * @var string
     */
    private static $report_to_group = 'signify-csp-violation';


    /**
     * Can isCSPReportingOnly be used safely.
     *
     * This is not a config option.
     *
     * @var boolean
     */
    private static $is_csp_reporting_only_safe = false;


    public function process(HTTPRequest $request, callable $delegate)
    {
        $response = $delegate($request);

        $headersConfig = (array) $this->config()->get('headers');
        if (empty($headersConfig['global'])) {
            return $response;
        }

        $headersToSend = $headersConfig['global'];
        if ($this->config()->get('enable_reporting') && $this->config()->get('use_report_to')) {
            $this->addReportToHeader($headersToSend);
        }
        // Update CSP header.
        if (array_key_exists('Content-Security-Policy', $headersToSend)) {
            $header = 'Content-Security-Policy';
            $headerValue = $headersToSend['Content-Security-Policy'];
            // Set report only mode if appropriate.
            if ($this->isCSPReportingOnly()) {
                unset($headersToSend['Content-Security-Policy']);
                $header = 'Content-Security-Policy-Report-Only';
            }
            // Update CSP header value.
            $headersToSend[$header] = $this->updateCspHeader($headerValue);
        }
        $this->extend('updateHeaders', $headersToSend, $request);

        // Add headers to response.
        foreach ($headersToSend as $header => $value) {
            if (empty($value)) {
                continue;
            }
            $value = preg_replace('/\v/', '', $value);
            $this->extend('updateHeader', $header, $value, $request);
            if ($value) {
                $response->addHeader($header, $value);
            }
        }

        return $response;
    }

    /**
     * Returns true if the Content-Security-Policy-Report-Only header should be used.
     *
     * @return boolean
     */
    public function isCSPReportingOnly()
    {
        return self::isCSPReportingOnlyAvailable() ? SiteConfig::current_site_config()->CSPReportingOnly : false;
        return self::/** @scrutinizer ignore-call */ isCSPReportingOnlyAvailable() ? SiteConfig::current_site_config()->CSPReportingOnly : false;
    }

    protected function getReportURI()
    {
        return Director::absoluteURL($this->config()->get('report_uri'));
    }

    protected function getIncludeSubdomains()
    {
        return $this->config()->get('report_to_subdomains');
    }

    protected function getReportToGroup()
    {
        return $this->config()->get('report_to_group');
    }

    protected function getReportURIDirective()
    {
        return "report-uri {$this->getReportURI()}";
    }

    protected function getReportToDirective()
    {
        return "report-to {$this->getReportToGroup()}";
    }

    protected function addReportToHeader(&$headers)
    {
        if (array_key_exists('Report-To', $headers)) {
            $headers['Report-To'] = $headers['Report-To'] . ',' . $this->getReportToHeader();
        } else {
            $headers['Report-To'] = $this->getReportToHeader();
        }
    }

    protected function getReportToHeader()
    {
        $header = [
            'group' => $this->getReportToGroup(),
            'max_age' => 1800,
            'endpoints' => [[
                'url' => $this->getReportURI(),
            ],],
            'include_subdomains' => $this->getIncludeSubdomains(),
        ];
        return json_encode($header);
    }

    protected function updateCspHeader($cspHeader)
    {
        if ($this->config()->get('enable_reporting')) {
            // Add or update report-uri directive.
            if (strpos($cspHeader, 'report-uri')) {
                $cspHeader = str_replace('report-uri', $this->getReportURIDirective(), $cspHeader);
            } else {
                $cspHeader = rtrim($cspHeader, ';') . "; {$this->getReportURIDirective()};";
            }

            // Add report-to directive.
            // Note that unlike report-uri, only the first endpoint is used if multiple are declared.
            if ($this->config()->get('use_report_to')) {
                if (strpos($cspHeader, 'report-to') === false) {
                    $cspHeader = rtrim($cspHeader, ';') . "; {$this->getReportToDirective()};";
                }
            }
        }

        return $cspHeader;
    }

    /**
     * Is the CSPReportingOnly field safe to read.
     *
     * If the module is installed and the codebase is flushed before the database has been built,
     * accessing SiteConfig causes an error.
     *
     * @return boolean
     */
    private function isCSPReportingOnlyAvailable()
    {
        // Cached true value.
        if (self::$is_csp_reporting_only_safe) {
            return self::$is_csp_reporting_only_safe;
        }

        // Basically SiteConfig, but it could be an injected class.
        $classes = ClassInfo::classesWithExtension(SecurityHeaderSiteconfigExtension::class);

        // Check if all tables and fields required for the class exist in the database.
        $requiredClasses = [];
        foreach ($classes as $class) {
            $requiredClasses += ClassInfo::dataClassesFor($class);
        }

        $schema = DataObject::getSchema();
        foreach ($requiredClasses as $required) {
            // Skip test classes, as not all test classes are scaffolded at once
            if (is_a($required, TestOnly::class, true)) {
                continue;
            }

            // if any of the tables aren't created in the database
            $table = $schema->tableName($required);
            if (!ClassInfo::hasTable($table)) {
                return false;
            }

            // if any of the tables don't have all fields mapped as table columns
            $dbFields = DB::field_list($table);
            if (!isset($dbFields['CSPReportingOnly'])) {
                return false;
            }
        }

        self::$is_csp_reporting_only_safe = true;

        return true;
    }
}

signify-nz / silverstripe-security-headers

Push — master ( afecc8...a1ff37 )

SecurityHeaderMiddleware::getReportToHeader() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
