IdPDisco.php

Go to the documentation of this file.

<?php
 
 
class SimpleSAML_XHTML_IdPDisco
{
 
    protected $config;
 
    protected $instance;
 
 
    protected $metadata;
 
 
    protected $session;
 
 
    protected $metadataSets;
 
 
    protected $spEntityId;
 
    protected $isPassive;
 
    protected $setIdPentityID = null;
 
 
    protected $returnIdParam;
 
    protected $scopedIDPList = array();
 
    protected $returnURL;
 
 
    public function __construct(array $metadataSets, $instance)
    {
        assert(is_string($instance));
 
        // initialize standard classes
        $this->config = SimpleSAML_Configuration::getInstance();
        $this->metadata = SimpleSAML_Metadata_MetaDataStorageHandler::getMetadataHandler();
        $this->session = SimpleSAML_Session::getSessionFromRequest();
        $this->instance = $instance;
        $this->metadataSets = $metadataSets;
 
        $this->log('Accessing discovery service.');
 
        // standard discovery service parameters
        if (!array_key_exists('entityID', $_GET)) {
            throw new Exception('Missing parameter: entityID');
        } else {
            $this->spEntityId = $_GET['entityID'];
        }
 
        if (!array_key_exists('returnIDParam', $_GET)) {
            $this->returnIdParam = 'entityID';
        } else {
            $this->returnIdParam = $_GET['returnIDParam'];
        }
 
        $this->log('returnIdParam initially set to ['.$this->returnIdParam.']');
 
        if (!array_key_exists('return', $_GET)) {
            throw new Exception('Missing parameter: return');
        } else {
            $this->returnURL = \SimpleSAML\Utils\HTTP::checkURLAllowed($_GET['return']);
        }
 
        $this->isPassive = false;
        if (array_key_exists('isPassive', $_GET)) {
            if ($_GET['isPassive'] === 'true') {
                $this->isPassive = true;
            }
        }
        $this->log('isPassive initially set to ['.($this->isPassive ? 'TRUE' : 'FALSE').']');
 
        if (array_key_exists('IdPentityID', $_GET)) {
            $this->setIdPentityID = $_GET['IdPentityID'];
        }
 
        if (array_key_exists('IDPList', $_REQUEST)) {
            $this->scopedIDPList = $_REQUEST['IDPList'];
        }
    }
 
 
    protected function log($message)
    {
        SimpleSAML\Logger::info('idpDisco.'.$this->instance.': '.$message);
    }
 
 
    protected function getCookie($name)
    {
        $prefixedName = 'idpdisco_'.$this->instance.'_'.$name;
        if (array_key_exists($prefixedName, $_COOKIE)) {
            return $_COOKIE[$prefixedName];
        } else {
            return null;
        }
    }
 
 
    protected function setCookie($name, $value)
    {
        $prefixedName = 'idpdisco_'.$this->instance.'_'.$name;
 
        $params = array(
            // we save the cookies for 90 days
            'lifetime' => (60 * 60 * 24 * 90),
            // the base path for cookies. This should be the installation directory for SimpleSAMLphp
            'path'     => $this->config->getBasePath(),
            'httponly' => false,
        );
 
        \SimpleSAML\Utils\HTTP::setCookie($prefixedName, $value, $params, false);
    }
 
 
    protected function validateIdP($idp)
    {
        if ($idp === null) {
            return null;
        }
 
        if (!$this->config->getBoolean('idpdisco.validate', true)) {
            return $idp;
        }
 
        foreach ($this->metadataSets as $metadataSet) {
            try {
                $this->metadata->getMetaData($idp, $metadataSet);
                return $idp;
            } catch (Exception $e) {
                // continue
            }
        }
 
        $this->log('Unable to validate IdP entity id ['.$idp.'].');
 
        // the entity id wasn't valid
        return null;
    }
 
 
    protected function getSelectedIdP()
    {
        /* Parameter set from the Extended IdP Metadata Discovery Service Protocol, indicating that the user prefers
         * this IdP.
         */
        if (!empty($this->setIdPentityID)) {
            return $this->validateIdP($this->setIdPentityID);
        }
 
        // user has clicked on a link, or selected the IdP from a drop-down list
        if (array_key_exists('idpentityid', $_GET)) {
            return $this->validateIdP($_GET['idpentityid']);
        }
 
        /* Search for the IdP selection from the form used by the links view. This form uses a name which equals
         * idp_<entityid>, so we search for that.
         *
         * Unfortunately, php replaces periods in the name with underscores, and there is no reliable way to get them
         * back. Therefore we do some quick and dirty parsing of the query string.
         */
        $qstr = $_SERVER['QUERY_STRING'];
        $matches = array();
        if (preg_match('/(?:^|&)idp_([^=]+)=/', $qstr, $matches)) {
            return $this->validateIdP(urldecode($matches[1]));
        }
 
        // no IdP chosen
        return null;
    }
 
 
    protected function getSavedIdP()
    {
        if (!$this->config->getBoolean('idpdisco.enableremember', false)) {
            // saving of IdP choices is disabled
            return null;
        }
 
        if ($this->getCookie('remember') === '1') {
            $this->log('Return previously saved IdP because of remember cookie set to 1');
            return $this->getPreviousIdP();
        }
 
        if ($this->isPassive) {
            $this->log('Return previously saved IdP because of isPassive');
            return $this->getPreviousIdP();
        }
 
        return null;
    }
 
 
    protected function getPreviousIdP()
    {
        return $this->validateIdP($this->getCookie('lastidp'));
    }
 
 
    protected function getFromCIDRhint()
    {
        foreach ($this->metadataSets as $metadataSet) {
            $idp = $this->metadata->getPreferredEntityIdFromCIDRhint($metadataSet, $_SERVER['REMOTE_ADDR']);
            if (!empty($idp)) {
                return $idp;
            }
        }
 
        return null;
    }
 
 
    protected function getRecommendedIdP()
    {
        $idp = $this->getPreviousIdP();
        if ($idp !== null) {
            $this->log('Preferred IdP from previous use ['.$idp.'].');
            return $idp;
        }
 
        $idp = $this->getFromCIDRhint();
 
        if (!empty($idp)) {
            $this->log('Preferred IdP from CIDR hint ['.$idp.'].');
            return $idp;
        }
 
        return null;
    }
 
 
    protected function setPreviousIdP($idp)
    {
        assert(is_string($idp));
 
        $this->log('Choice made ['.$idp.'] Setting cookie.');
        $this->setCookie('lastidp', $idp);
    }
 
 
    protected function saveIdP()
    {
        if (!$this->config->getBoolean('idpdisco.enableremember', false)) {
            // saving of IdP choices is disabled
            return false;
        }
 
        if (array_key_exists('remember', $_GET)) {
            return true;
        }
 
        return false;
    }
 
 
    protected function getTargetIdP()
    {
        // first, check if the user has chosen an IdP
        $idp = $this->getSelectedIdP();
        if ($idp !== null) {
            // the user selected this IdP. Save the choice in a cookie
            $this->setPreviousIdP($idp);
 
            if ($this->saveIdP()) {
                $this->setCookie('remember', '1');
            } else {
                $this->setCookie('remember', '0');
            }
 
            return $idp;
        }
 
        $this->log('getSelectedIdP() returned null');
 
        // check if the user has saved an choice earlier
        $idp = $this->getSavedIdP();
        if ($idp !== null) {
            $this->log('Using saved choice ['.$idp.'].');
            return $idp;
        }
 
        // the user has made no choice
        return null;
    }
 
 
    protected function getIdPList()
    {
        $idpList = array();
        foreach ($this->metadataSets as $metadataSet) {
            $newList = $this->metadata->getList($metadataSet);
            /*
             * Note that we merge the entities in reverse order. This ensures that it is the entity in the first
             * metadata set that "wins" if two metadata sets have the same entity.
             */
            $idpList = array_merge($newList, $idpList);
        }
 
        return $idpList;
    }
 
 
    protected function getScopedIDPList()
    {
        return $this->scopedIDPList;
    }
 
 
    protected function filterList($list)
    {
        foreach ($list as $entity => $metadata) {
            if (array_key_exists('hide.from.discovery', $metadata) && $metadata['hide.from.discovery'] === true) {
                unset($list[$entity]);
            }
        }
        return $list;
    }
 
 
    protected function start()
    {
        $idp = $this->getTargetIdp();
        if ($idp !== null) {
            $extDiscoveryStorage = $this->config->getString('idpdisco.extDiscoveryStorage', null);
            if ($extDiscoveryStorage !== null) {
                $this->log('Choice made ['.$idp.'] (Forwarding to external discovery storage)');
                \SimpleSAML\Utils\HTTP::redirectTrustedURL($extDiscoveryStorage, array(
                    'entityID'      => $this->spEntityId,
                    'IdPentityID'   => $idp,
                    'returnIDParam' => $this->returnIdParam,
                    'isPassive'     => 'true',
                    'return'        => $this->returnURL
                ));
            } else {
                $this->log(
                    'Choice made ['.$idp.'] (Redirecting the user back. returnIDParam='.$this->returnIdParam.')'
                );
                \SimpleSAML\Utils\HTTP::redirectTrustedURL($this->returnURL, array($this->returnIdParam => $idp));
            }
        }
 
        if ($this->isPassive) {
            $this->log('Choice not made. (Redirecting the user back without answer)');
            \SimpleSAML\Utils\HTTP::redirectTrustedURL($this->returnURL);
        }
    }
 
 
    public function handleRequest()
    {
        $this->start();
 
        // no choice made. Show discovery service page
        $idpList = $this->getIdPList();
        $idpList = $this->filterList($idpList);
        $preferredIdP = $this->getRecommendedIdP();
 
        $idpintersection = array_intersect(array_keys($idpList), $this->getScopedIDPList());
        if (sizeof($idpintersection) > 0) {
            $idpList = array_intersect_key($idpList, array_fill_keys($idpintersection, null));
        }
 
        $idpintersection = array_values($idpintersection);
 
        if (sizeof($idpintersection) == 1) {
            $this->log(
                'Choice made ['.$idpintersection[0].'] (Redirecting the user back. returnIDParam='.
                $this->returnIdParam.')'
            );
            \SimpleSAML\Utils\HTTP::redirectTrustedURL(
                $this->returnURL,
                array($this->returnIdParam => $idpintersection[0])
            );
        }
 
        /*
         * Make use of an XHTML template to present the select IdP choice to the user. Currently the supported options
         * is either a drop down menu or a list view.
         */
        switch ($this->config->getString('idpdisco.layout', 'links')) {
            case 'dropdown':
                $templateFile = 'selectidp-dropdown.php';
                break;
            case 'links':
                $templateFile = 'selectidp-links.php';
                break;
            default:
                throw new Exception('Invalid value for the \'idpdisco.layout\' option.');
        }
 
        $t = new SimpleSAML_XHTML_Template($this->config, $templateFile, 'disco');
        $t->data['idplist'] = $idpList;
        $t->data['preferredidp'] = $preferredIdP;
        $t->data['return'] = $this->returnURL;
        $t->data['returnIDParam'] = $this->returnIdParam;
        $t->data['entityID'] = $this->spEntityId;
        $t->data['urlpattern'] = htmlspecialchars(\SimpleSAML\Utils\HTTP::getSelfURLNoQuery());
        $t->data['rememberenabled'] = $this->config->getBoolean('idpdisco.enableremember', false);
        $t->show();
    }
}