Session.php

Go to the documentation of this file.

<?php
class SimpleSAML_Session implements Serializable
{
 
    const DATA_TIMEOUT_SESSION_END = 'sessionEndTimeout';
 
 
    private static $sessions = array();
 
 
    private static $instance = null;
 
 
    private $sessionId;
 
 
    private $transient = false;
 
 
    private $trackid = null;
 
 
    private $rememberMeExpire = null;
 
 
    private $dirty = false;
 
 
    private $callback_registered = false;
 
 
    private $dataStore = null;
 
 
    private $associations = array();
 
 
    private $authToken;
 
 
    private $authData;
 
 
    private function __construct($transient = false)
    {
        $this->authData = array();
 
        if (php_sapi_name() === 'cli' || defined('STDIN')) {
            $this->trackid = 'CL'.bin2hex(openssl_random_pseudo_bytes(4));
            SimpleSAML\Logger::setTrackId($this->trackid);
            $this->transient = $transient;
            return;
        }
 
        if ($transient) { // transient session
            $sh = \SimpleSAML\SessionHandler::getSessionHandler();
            $this->trackid = 'TR'.bin2hex(openssl_random_pseudo_bytes(4));
            SimpleSAML\Logger::setTrackId($this->trackid);
            $this->transient = true;
 
            /*
             * Initialize the session ID. It might be that we have a session cookie but we couldn't load the session.
             * If that's the case, use that ID. If not, create a new ID.
             */
            $this->sessionId = $sh->getCookieSessionId();
            if ($this->sessionId === null) {
                $this->sessionId = $sh->newSessionId();
            }
        } else { // regular session
            $sh = \SimpleSAML\SessionHandler::getSessionHandler();
            $this->sessionId = $sh->newSessionId();
            $sh->setCookie($sh->getSessionCookieName(), $this->sessionId, $sh->getCookieParams());
 
 
            $this->trackid = bin2hex(openssl_random_pseudo_bytes(5));
            SimpleSAML\Logger::setTrackId($this->trackid);
 
            $this->markDirty();
 
            // initialize data for session check function if defined
            $globalConfig = SimpleSAML_Configuration::getInstance();
            $checkFunction = $globalConfig->getArray('session.check_function', null);
            if (isset($checkFunction)) {
                assert('is_callable($checkFunction)');
                call_user_func($checkFunction, $this, true);
            }
        }
    }
 
 
    public function serialize()
    {
        $serialized = serialize(get_object_vars($this));
        return $serialized;
    }
 
 
    public function unserialize($serialized)
    {
        $session = unserialize($serialized);
        if (is_array($session)) {
            foreach ($session as $k => $v) {
                $this->$k = $v;
            }
        }
 
        // look for any raw attributes and load them in the 'Attributes' array
        foreach ($this->authData as $authority => $parameters) {
            if (!array_key_exists('RawAttributes', $parameters)) {
                continue;
            }
 
            foreach ($parameters['RawAttributes'] as $attribute => $values) {
                foreach ($values as $idx => $value) { // this should be originally a DOMNodeList
                    /* @var \SAML2\XML\saml\AttributeValue $value */
                    $this->authData[$authority]['Attributes'][$attribute][$idx] = $value->element->childNodes;
                }
            }
        }
    }
 
 
    public static function getSessionFromRequest()
    {
        // check if we already have initialized the session
        if (isset(self::$instance)) {
            return self::$instance;
        }
 
        // check if we have stored a session stored with the session handler
        $session = null;
        try {
            $session = self::getSession();
        } catch (Exception $e) {
            /*
             * For some reason, we were unable to initialize this session. Note that this error might be temporary, and
             * it's possible that we can recover from it in subsequent requests, so we should not try to create a new
             * session here. Therefore, use just a transient session and throw the exception for someone else to handle
             * it.
             */
            SimpleSAML\Logger::error('Error loading session: '.$e->getMessage());
            self::useTransientSession();
            if ($e instanceof SimpleSAML_Error_Exception) {
                $cause = $e->getCause();
                if ($cause instanceof Exception) {
                    throw $cause;
                }
            }
            throw $e;
        }
 
        // if getSession() found it, use it
        if ($session instanceof SimpleSAML_Session) {
            return self::load($session);
        }
 
        /*
         * We didn't have a session loaded when we started, but we have it now. At this point, getSession() failed but
         * it must have triggered the creation of a session at some point during the process (e.g. while logging an
         * error message). This means we don't need to create a new session again, we can use the one that's loaded now
         * instead.
         */
        if (self::$instance !== null) {
            return self::$instance;
        }
 
        // try to create a new session
        try {
            self::load(new SimpleSAML_Session());
        } catch (\SimpleSAML\Error\CannotSetCookie $e) {
            // can't create a regular session because we can't set cookies. Use transient.
            $c = SimpleSAML_Configuration::getInstance();
            self::useTransientSession();
 
            if ($e->getCode() === \SimpleSAML\Error\CannotSetCookie::SECURE_COOKIE) {
                throw new \SimpleSAML\Error\CriticalConfigurationError(
                    $e->getMessage(),
                    null,
                    $c->toArray()
                );
            }
            SimpleSAML\Logger::error('Error creating session: '.$e->getMessage());
        }
 
        // we must have a session now, either regular or transient
        return self::$instance;
    }
 
    public static function getSession($sessionId = null)
    {
        assert('is_string($sessionId) || is_null($sessionId)');
 
        $sh = \SimpleSAML\SessionHandler::getSessionHandler();
 
        if ($sessionId === null) {
            $checkToken = true;
            $sessionId = $sh->getCookieSessionId();
            if ($sessionId === null) {
                return null;
            }
        } else {
            $checkToken = false;
        }
 
        if (array_key_exists($sessionId, self::$sessions)) {
            return self::$sessions[$sessionId];
        }
 
        $session = $sh->loadSession($sessionId);
        if ($session === null) {
            return null;
        }
 
        assert('$session instanceof self');
 
        if ($checkToken) {
            $globalConfig = SimpleSAML_Configuration::getInstance();
 
            if ($session->authToken !== null) {
                $authTokenCookieName = $globalConfig->getString(
                    'session.authtoken.cookiename',
                    'SimpleSAMLAuthToken'
                );
                if (!isset($_COOKIE[$authTokenCookieName])) {
                    SimpleSAML\Logger::warning('Missing AuthToken cookie.');
                    return null;
                }
                if (!SimpleSAML\Utils\Crypto::secureCompare($session->authToken, $_COOKIE[$authTokenCookieName])) {
                    SimpleSAML\Logger::warning('Invalid AuthToken cookie.');
                    return null;
                }
            }
 
            // run session check function if defined
            $checkFunction = $globalConfig->getArray('session.check_function', null);
            if (isset($checkFunction)) {
                assert('is_callable($checkFunction)');
                $check = call_user_func($checkFunction, $session);
                if ($check !== true) {
                    SimpleSAML\Logger::warning('Session did not pass check function.');
                    return null;
                }
            }
        }
 
        self::$sessions[$sessionId] = $session;
 
        return $session;
    }
 
 
    private static function load(SimpleSAML_Session $session)
    {
        SimpleSAML\Logger::setTrackId($session->getTrackID());
        self::$instance = $session;
        return self::$instance;
    }
 
    public static function useTransientSession()
    {
        if (isset(self::$instance)) {
            // we already have a session, don't bother with a transient session
            return;
        }
 
        self::load(new SimpleSAML_Session(true));
    }
 
    public static function createSession($sessionId)
    {
        assert('is_string($sessionId)');
        self::$sessions[$sessionId] = null;
    }
 
    public function save()
    {
        if (!$this->dirty) {
            // session hasn't changed, don't bother saving it
            return;
        }
 
        $this->dirty = false;
        $this->callback_registered = false;
 
        $sh = \SimpleSAML\SessionHandler::getSessionHandler();
 
        try {
            $sh->saveSession($this);
        } catch (Exception $e) {
            if (!($e instanceof SimpleSAML_Error_Exception)) {
                $e = new SimpleSAML_Error_UnserializableException($e);
            }
            SimpleSAML\Logger::error('Unable to save session.');
            $e->logError();
        }
    }
 
 
    public function cleanup()
    {
        $this->save();
        $sh = \SimpleSAML\SessionHandler::getSessionHandler();
        if ($sh instanceof \SimpleSAML\SessionHandlerPHP) {
            $sh->restorePrevious();
        }
    }
 
 
    public function markDirty()
    {
        if ($this->isTransient()) {
            return;
        }
 
        $this->dirty = true;
 
        if (!function_exists('header_register_callback')) {
            // PHP version < 5.4, can't register the callback
            return;
        }
 
        if ($this->callback_registered) {
            // we already have a shutdown callback registered for this object, no need to add another one
            return;
        }
        $this->callback_registered = header_register_callback(array($this, 'save'));
    }
 
 
    public function __destruct()
    {
        $this->save();
    }
 
    public function getSessionId()
    {
        return $this->sessionId;
    }
 
    public function isTransient()
    {
        return $this->transient;
    }
 
    public function getTrackID()
    {
        return $this->trackid;
    }
 
    public function getRememberMeExpire()
    {
        return $this->rememberMeExpire;
    }
 
    public function setRememberMeExpire($expire = null)
    {
        assert('is_int($expire) || is_null($expire)');
 
        if ($expire === null) {
            $globalConfig = SimpleSAML_Configuration::getInstance();
            $expire = time() + $globalConfig->getInteger('session.rememberme.lifetime', 14 * 86400);
        }
        $this->rememberMeExpire = $expire;
 
        $cookieParams = array('expire' => $this->rememberMeExpire);
        $this->updateSessionCookies($cookieParams);
    }
 
    public function doLogin($authority, array $data = null)
    {
        assert('is_string($authority)');
        assert('is_array($data) || is_null($data)');
 
        SimpleSAML\Logger::debug('Session: doLogin("'.$authority.'")');
 
        $this->markDirty();
 
        if (isset($this->authData[$authority])) {
            // we are already logged in, log the user out first
            $this->doLogout($authority);
        }
 
        if ($data === null) {
            $data = array();
        }
 
        $data['Authority'] = $authority;
 
        $globalConfig = SimpleSAML_Configuration::getInstance();
        if (!isset($data['AuthnInstant'])) {
            $data['AuthnInstant'] = time();
        }
 
        $maxSessionExpire = time() + $globalConfig->getInteger('session.duration', 8 * 60 * 60);
        if (!isset($data['Expire']) || $data['Expire'] > $maxSessionExpire) {
            // unset, or beyond our session lifetime. Clamp it to our maximum session lifetime
            $data['Expire'] = $maxSessionExpire;
        }
 
        // check if we have non-serializable attribute values
        foreach ($data['Attributes'] as $attribute => $values) {
            foreach ($values as $idx => $value) {
                if (is_string($value) || is_int($value)) {
                    continue;
                }
 
                // at this point, this should be a DOMNodeList object...
                if (!is_a($value, 'DOMNodeList')) {
                    continue;
                }
 
                /* @var \DOMNodeList $value */
                if ($value->length === 0) {
                    continue;
                }
 
                // create an AttributeValue object and save it to 'RawAttributes', using same attribute name and index
                $attrval = new \SAML2\XML\saml\AttributeValue($value->item(0)->parentNode);
                $data['RawAttributes'][$attribute][$idx] = $attrval;
            }
        }
 
        $this->authData[$authority] = $data;
 
        $this->authToken = SimpleSAML\Utils\Random::generateID();
        $sessionHandler = \SimpleSAML\SessionHandler::getSessionHandler();
 
        if (!$this->transient && (!empty($data['RememberMe']) || $this->rememberMeExpire) &&
            $globalConfig->getBoolean('session.rememberme.enable', false)
        ) {
 
            $this->setRememberMeExpire();
        } else {
            try {
                SimpleSAML\Utils\HTTP::setCookie(
                    $globalConfig->getString('session.authtoken.cookiename', 'SimpleSAMLAuthToken'),
                    $this->authToken,
                    $sessionHandler->getCookieParams()
                );
            } catch (SimpleSAML\Error\CannotSetCookie $e) {
                /*
                 * Something went wrong when setting the auth token. We cannot recover from this, so we better log a
                 * message and throw an exception. The user is not properly logged in anyway, so clear all login
                 * information from the session.
                 */
                unset($this->authToken);
                unset($this->authData[$authority]);
                \SimpleSAML\Logger::error('Cannot set authentication token cookie: '.$e->getMessage());
                throw $e;
            }
        }
    }
 
    public function doLogout($authority)
    {
        SimpleSAML\Logger::debug('Session: doLogout('.var_export($authority, true).')');
 
        if (!isset($this->authData[$authority])) {
            SimpleSAML\Logger::debug('Session: Already logged out of '.$authority.'.');
            return;
        }
 
        $this->markDirty();
 
        $this->callLogoutHandlers($authority);
        unset($this->authData[$authority]);
 
        if (!$this->isValid($authority) && $this->rememberMeExpire) {
            $this->rememberMeExpire = null;
            $this->updateSessionCookies();
        }
    }
 
    private function callLogoutHandlers($authority)
    {
        assert('is_string($authority)');
        assert('isset($this->authData[$authority])');
 
        if (empty($this->authData[$authority]['LogoutHandlers'])) {
            return;
        }
        foreach ($this->authData[$authority]['LogoutHandlers'] as $handler) {
            // verify that the logout handler is a valid function
            if (!is_callable($handler)) {
                $classname = $handler[0];
                $functionname = $handler[1];
 
                throw new Exception(
                    'Logout handler is not a valid function: '.$classname.'::'.
                    $functionname
                );
            }
 
            // call the logout handler
            call_user_func($handler);
        }
 
        // we require the logout handlers to register themselves again if they want to be called later
        unset($this->authData[$authority]['LogoutHandlers']);
    }
 
    public function isValid($authority)
    {
        assert('is_string($authority)');
 
        if (!isset($this->authData[$authority])) {
            SimpleSAML\Logger::debug(
                'Session: '.var_export($authority, true).
                ' not valid because we are not authenticated.'
            );
            return false;
        }
 
        if ($this->authData[$authority]['Expire'] <= time()) {
            SimpleSAML\Logger::debug('Session: '.var_export($authority, true).' not valid because it is expired.');
            return false;
        }
 
        SimpleSAML\Logger::debug('Session: Valid session found with '.var_export($authority, true).'.');
 
        return true;
    }
 
    public function updateSessionCookies($params = null)
    {
        $sessionHandler = \SimpleSAML\SessionHandler::getSessionHandler();
 
        if ($this->sessionId !== null) {
            $sessionHandler->setCookie($sessionHandler->getSessionCookieName(), $this->sessionId, $params);
        }
 
        if ($this->authToken !== null) {
            $globalConfig = SimpleSAML_Configuration::getInstance();
            \SimpleSAML\Utils\HTTP::setCookie(
                $globalConfig->getString('session.authtoken.cookiename', 'SimpleSAMLAuthToken'),
                $this->authToken,
                $params
            );
        }
    }
 
    public function setAuthorityExpire($authority, $expire = null)
    {
        assert('isset($this->authData[$authority])');
        assert('is_int($expire) || is_null($expire)');
 
        $this->markDirty();
 
        if ($expire === null) {
            $globalConfig = SimpleSAML_Configuration::getInstance();
            $expire = time() + $globalConfig->getInteger('session.duration', 8 * 60 * 60);
        }
 
        $this->authData[$authority]['Expire'] = $expire;
    }
 
    public function registerLogoutHandler($authority, $classname, $functionname)
    {
        assert('isset($this->authData[$authority])');
 
        $logout_handler = array($classname, $functionname);
 
        if (!is_callable($logout_handler)) {
            throw new Exception(
                'Logout handler is not a vaild function: '.$classname.'::'.
                $functionname
            );
        }
 
        $this->authData[$authority]['LogoutHandlers'][] = $logout_handler;
        $this->markDirty();
    }
 
    public function deleteData($type, $id)
    {
        assert('is_string($type)');
        assert('is_string($id)');
 
        if (!is_array($this->dataStore)) {
            return;
        }
 
        if (!array_key_exists($type, $this->dataStore)) {
            return;
        }
 
        unset($this->dataStore[$type][$id]);
        $this->markDirty();
    }
 
    public function setData($type, $id, $data, $timeout = null)
    {
        assert('is_string($type)');
        assert('is_string($id)');
        assert('is_int($timeout) || is_null($timeout) || $timeout === self::DATA_TIMEOUT_SESSION_END');
 
        // clean out old data
        $this->expireData();
 
        if ($timeout === null) {
            // use the default timeout
            $configuration = SimpleSAML_Configuration::getInstance();
 
            $timeout = $configuration->getInteger('session.datastore.timeout', null);
            if ($timeout !== null) {
                if ($timeout <= 0) {
                    throw new Exception(
                        'The value of the session.datastore.timeout'.
                        ' configuration option should be a positive integer.'
                    );
                }
            }
        }
 
        if ($timeout === self::DATA_TIMEOUT_SESSION_END) {
            $expires = self::DATA_TIMEOUT_SESSION_END;
        } else {
            $expires = time() + $timeout;
        }
 
        $dataInfo = array(
            'expires' => $expires,
            'timeout' => $timeout,
            'data'    => $data
        );
 
        if (!is_array($this->dataStore)) {
            $this->dataStore = array();
        }
 
        if (!array_key_exists($type, $this->dataStore)) {
            $this->dataStore[$type] = array();
        }
 
        $this->dataStore[$type][$id] = $dataInfo;
 
        $this->markDirty();
    }
 
    private function expireData()
    {
        if (!is_array($this->dataStore)) {
            return;
        }
 
        $ct = time();
 
        foreach ($this->dataStore as &$typedData) {
            foreach ($typedData as $id => $info) {
                if ($info['expires'] === self::DATA_TIMEOUT_SESSION_END) {
                    // this data never expires
                    continue;
                }
 
                if ($ct > $info['expires']) {
                    unset($typedData[$id]);
                }
            }
        }
    }
 
    public function getData($type, $id)
    {
        assert('is_string($type)');
        assert('$id === null || is_string($id)');
 
        if ($id === null) {
            return null;
        }
 
        $this->expireData();
 
        if (!is_array($this->dataStore)) {
            return null;
        }
 
        if (!array_key_exists($type, $this->dataStore)) {
            return null;
        }
 
        if (!array_key_exists($id, $this->dataStore[$type])) {
            return null;
        }
 
        return $this->dataStore[$type][$id]['data'];
    }
 
    public function getDataOfType($type)
    {
        assert('is_string($type)');
 
        if (!is_array($this->dataStore)) {
            return array();
        }
 
        if (!array_key_exists($type, $this->dataStore)) {
            return array();
        }
 
        $ret = array();
        foreach ($this->dataStore[$type] as $id => $info) {
            $ret[$id] = $info['data'];
        }
 
        return $ret;
    }
 
    public function getAuthState($authority)
    {
        assert('is_string($authority)');
 
        if (!isset($this->authData[$authority])) {
            return null;
        }
 
        return $this->authData[$authority];
    }
 
 
    public function hasSessionCookie()
    {
        $sh = \SimpleSAML\SessionHandler::getSessionHandler();
        return $sh->hasSessionCookie();
    }
 
 
    public function addAssociation($idp, array $association)
    {
        assert('is_string($idp)');
        assert('isset($association["id"])');
        assert('isset($association["Handler"])');
 
        if (!isset($this->associations)) {
            $this->associations = array();
        }
 
        if (!isset($this->associations[$idp])) {
            $this->associations[$idp] = array();
        }
 
        $this->associations[$idp][$association['id']] = $association;
 
        $this->markDirty();
    }
 
 
    public function getAssociations($idp)
    {
        assert('is_string($idp)');
 
        if (!isset($this->associations)) {
            $this->associations = array();
        }
 
        if (!isset($this->associations[$idp])) {
            return array();
        }
 
        foreach ($this->associations[$idp] as $id => $assoc) {
            if (!isset($assoc['Expires'])) {
                continue;
            }
            if ($assoc['Expires'] >= time()) {
                continue;
            }
 
            unset($this->associations[$idp][$id]);
        }
 
        return $this->associations[$idp];
    }
 
 
    public function terminateAssociation($idp, $associationId)
    {
        assert('is_string($idp)');
        assert('is_string($associationId)');
 
        if (!isset($this->associations)) {
            return;
        }
 
        if (!isset($this->associations[$idp])) {
            return;
        }
 
        unset($this->associations[$idp][$associationId]);
 
        $this->markDirty();
    }
 
 
    public function getAuthData($authority, $name)
    {
        assert('is_string($authority)');
        assert('is_string($name)');
 
        if (!isset($this->authData[$authority][$name])) {
            return null;
        }
        return $this->authData[$authority][$name];
    }
 
 
    public function getAuthorities()
    {
        $authorities = array();
        foreach (array_keys($this->authData) as $authority) {
            if ($this->isValid($authority)) {
                $authorities[] = $authority;
            }
        }
        return $authorities;
    }
}