Simple.php

Go to the documentation of this file.

<?php
 
namespace SimpleSAML\Auth;
 
use \SimpleSAML_Auth_Source as Source;
use \SimpleSAML_Auth_State as State;
use \SimpleSAML_Configuration as Configuration;
use \SimpleSAML_Error_AuthSource as AuthSourceError;
use \SimpleSAML\Module;
use \SimpleSAML_Session as Session;
use \SimpleSAML\Utils\HTTP;
 
class Simple
{
 
    protected $authSource;
 
    protected $app_config;
 
    public function __construct($authSource)
    {
        assert(is_string($authSource));
 
        $this->authSource = $authSource;
        $this->app_config = Configuration::getInstance()->getConfigItem('application', null);
    }
 
 
    public function getAuthSource()
    {
        $as = Source::getById($this->authSource);
        if ($as === null) {
            throw new AuthSourceError($this->authSource, 'Unknown authentication source.');
        }
        return $as;
    }
 
 
    public function isAuthenticated()
    {
        $session = Session::getSessionFromRequest();
 
        return $session->isValid($this->authSource);
    }
 
 
    public function requireAuth(array $params = array())
    {
 
        $session = Session::getSessionFromRequest();
 
        if ($session->isValid($this->authSource)) {
            // Already authenticated
            return;
        }
 
        $this->login($params);
    }
 
 
    public function login(array $params = array())
    {
 
        if (array_key_exists('KeepPost', $params)) {
            $keepPost = (bool) $params['KeepPost'];
        } else {
            $keepPost = true;
        }
 
        if (array_key_exists('ReturnTo', $params)) {
            $returnTo = (string) $params['ReturnTo'];
        } else {
            if (array_key_exists('ReturnCallback', $params)) {
                $returnTo = (array) $params['ReturnCallback'];
            } else {
                $returnTo = HTTP::getSelfURL();
            }
        }
 
        if (is_string($returnTo) && $keepPost && $_SERVER['REQUEST_METHOD'] === 'POST') {
            $returnTo = HTTP::getPOSTRedirectURL($returnTo, $_POST);
        }
 
        if (array_key_exists('ErrorURL', $params)) {
            $errorURL = (string) $params['ErrorURL'];
        } else {
            $errorURL = null;
        }
 
 
        if (!isset($params[State::RESTART]) && is_string($returnTo)) {
            /*
             * A URL to restart the authentication, in case the user bookmarks
             * something, e.g. the discovery service page.
             */
            $restartURL = $this->getLoginURL($returnTo);
            $params[State::RESTART] = $restartURL;
        }
 
        $as = $this->getAuthSource();
        $as->initLogin($returnTo, $errorURL, $params);
        assert(false);
    }
 
 
    public function logout($params = null)
    {
        assert(is_array($params) || is_string($params) || $params === null);
 
        if ($params === null) {
            $params = HTTP::getSelfURL();
        }
 
        if (is_string($params)) {
            $params = array(
                'ReturnTo' => $params,
            );
        }
 
        assert(is_array($params));
        assert(isset($params['ReturnTo']) || isset($params['ReturnCallback']));
 
        if (isset($params['ReturnStateParam']) || isset($params['ReturnStateStage'])) {
            assert(isset($params['ReturnStateParam'], $params['ReturnStateStage']));
        }
 
        $session = Session::getSessionFromRequest();
        if ($session->isValid($this->authSource)) {
            $state = $session->getAuthData($this->authSource, 'LogoutState');
            if ($state !== null) {
                $params = array_merge($state, $params);
            }
 
            $session->doLogout($this->authSource);
 
            $params['LogoutCompletedHandler'] = array(get_class(), 'logoutCompleted');
 
            $as = Source::getById($this->authSource);
            if ($as !== null) {
                $as->logout($params);
            }
        }
 
        self::logoutCompleted($params);
    }
 
 
    public static function logoutCompleted($state)
    {
        assert(is_array($state));
        assert(isset($state['ReturnTo']) || isset($state['ReturnCallback']));
 
        if (isset($state['ReturnCallback'])) {
            call_user_func($state['ReturnCallback'], $state);
            assert(false);
        } else {
            $params = array();
            if (isset($state['ReturnStateParam']) || isset($state['ReturnStateStage'])) {
                assert(isset($state['ReturnStateParam'], $state['ReturnStateStage']));
                $stateID = State::saveState($state, $state['ReturnStateStage']);
                $params[$state['ReturnStateParam']] = $stateID;
            }
            \SimpleSAML\Utils\HTTP::redirectTrustedURL($state['ReturnTo'], $params);
        }
    }
 
 
    public function getAttributes()
    {
 
        if (!$this->isAuthenticated()) {
            // Not authenticated
            return array();
        }
 
        // Authenticated
        $session = Session::getSessionFromRequest();
        return $session->getAuthData($this->authSource, 'Attributes');
    }
 
 
    public function getAuthData($name)
    {
        assert(is_string($name));
 
        if (!$this->isAuthenticated()) {
            return null;
        }
 
        $session = Session::getSessionFromRequest();
        return $session->getAuthData($this->authSource, $name);
    }
 
 
    public function getAuthDataArray()
    {
 
        if (!$this->isAuthenticated()) {
            return null;
        }
 
        $session = Session::getSessionFromRequest();
        return $session->getAuthState($this->authSource);
    }
 
 
    public function getLoginURL($returnTo = null)
    {
        assert($returnTo === null || is_string($returnTo));
 
        if ($returnTo === null) {
            $returnTo = HTTP::getSelfURL();
        }
 
        $login = Module::getModuleURL('core/as_login.php', array(
            'AuthId'   => $this->authSource,
            'ReturnTo' => $returnTo,
        ));
 
        return $login;
    }
 
 
    public function getLogoutURL($returnTo = null)
    {
        assert($returnTo === null || is_string($returnTo));
 
        if ($returnTo === null) {
            $returnTo = HTTP::getSelfURL();
        }
 
        $logout = Module::getModuleURL('core/as_logout.php', array(
            'AuthId'   => $this->authSource,
            'ReturnTo' => $returnTo,
        ));
 
        return $logout;
    }
 
 
    protected function getProcessedURL($url = null)
    {
        if ($url === null) {
            $url = HTTP::getSelfURL();
        }
 
        $scheme = parse_url($url, PHP_URL_SCHEME);
        $host = parse_url($url, PHP_URL_HOST) ?: HTTP::getSelfHost();
        $port = parse_url($url, PHP_URL_PORT) ?: (
            $scheme ? '' : trim(HTTP::getServerPort(), ':')
        );
        $scheme = $scheme ?: (HTTP::getServerHTTPS() ? 'https' : 'http');
        $path = parse_url($url, PHP_URL_PATH) ?: '/';
        $query = parse_url($url, PHP_URL_QUERY) ?: '';
        $fragment = parse_url($url, PHP_URL_FRAGMENT) ?: '';
 
        $port = !empty($port) ? ':'.$port : '';
        if (($scheme === 'http' && $port === ':80') || ($scheme === 'https' && $port === ':443')) {
            $port = '';
        }
 
        if (is_null($this->app_config)) {
            // nothing more we can do here
            return $scheme.'://'.$host.$port.$path.($query ? '?'.$query : '').($fragment ? '#'.$fragment : '');
        }
 
        $base =  trim($this->app_config->getString(
            'baseURL',
            $scheme.'://'.$host.$port
        ), '/');
        return $base.$path.($query ? '?'.$query : '').($fragment ? '#'.$fragment : '');
    }
}