AbstractUserAuthentication.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Authentication;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use TYPO3\CMS\Core\Database\DatabaseConnection;
use TYPO3\CMS\Core\Utility\GeneralUtility;

abstract class AbstractUserAuthentication
{
    public $session_table = '';

    public $name = '';

    public $get_name = '';

    public $user_table = '';

    public $usergroup_table = '';

    public $username_column = '';

    public $userident_column = '';

    public $userid_column = '';

    public $usergroup_column = '';

    public $lastLogin_column = '';

    public $enablecolumns = [
        'rootLevel' => '',
        // Boolean: If TRUE, 'AND pid=0' will be a part of the query...
        'disabled' => '',
        'starttime' => '',
        'endtime' => '',
        'deleted' => ''
    ];

    public $showHiddenRecords = false;

    public $formfield_uname = '';

    public $formfield_uident = '';

    public $formfield_status = '';

    public $auth_timeout_field = 0;

    public $lifetime = 0;

    public $gc_time = 0;

    public $gc_probability = 1;

    public $writeStdLog = false;

    public $writeAttemptLog = false;

    public $sendNoCacheHeaders = true;

    public $getFallBack = false;

    public $hash_length = 32;

    public $getMethodEnabled = false;

    public $lockIP = 4;

    public $lockHashKeyWords = 'useragent';

    public $warningEmail = '';

    public $warningPeriod = 3600;

    public $warningMax = 3;

    public $checkPid = true;

    public $checkPid_value = 0;

    public $id;

    public $loginFailure = false;

    public $loginSessionStarted = false;

    public $user = null;

    public $get_URL_ID = '';

    public $newSessionID = false;

    public $forceSetCookie = false;

    public $dontSetCookie = false;

    protected $cookieWasSetOnCurrentRequest = false;

    public $loginType = '';

    public $svConfig = [];

    public $writeDevLog = false;

    public $uc;

    protected $db = null;

    public function __construct()
    {
        $this->db = $this->getDatabaseConnection();
    }

    public function start()
    {
        // Backend or frontend login - used for auth services
        if (empty($this->loginType)) {
            throw new \TYPO3\CMS\Core\Exception('No loginType defined, should be set explicitly by subclass');
        }
        // Enable dev logging if set
        if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['writeDevLog']) {
            $this->writeDevLog = true;
        }
        if ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['writeDevLog' . $this->loginType]) {
            $this->writeDevLog = true;
        }
        if (TYPO3_DLOG) {
            $this->writeDevLog = true;
        }
        if ($this->writeDevLog) {
            GeneralUtility::devLog('## Beginning of auth logging.', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        // Init vars.
        $mode = '';
        $this->newSessionID = false;
        // $id is set to ses_id if cookie is present. Else set to FALSE, which will start a new session
        $id = $this->getCookie($this->name);
        $this->svConfig = $GLOBALS['TYPO3_CONF_VARS']['SVCONF']['auth'];

        // If fallback to get mode....
        if (!$id && $this->getFallBack && $this->get_name) {
            $id = isset($_GET[$this->get_name]) ? GeneralUtility::_GET($this->get_name) : '';
            if (strlen($id) != $this->hash_length) {
                $id = '';
            }
            $mode = 'get';
        }

        // If new session or client tries to fix session...
        if (!$id || !$this->isExistingSessionRecord($id)) {
            // New random session-$id is made
            $id = $this->createSessionId();
            // New session
            $this->newSessionID = true;
        }
        // Internal var 'id' is set
        $this->id = $id;
        // If fallback to get mode....
        if ($mode == 'get' && $this->getFallBack && $this->get_name) {
            $this->get_URL_ID = '&' . $this->get_name . '=' . $id;
        }
        // Set session hashKey lock keywords from configuration; currently only 'useragent' can be used.
        $this->lockHashKeyWords = $GLOBALS['TYPO3_CONF_VARS'][$this->loginType]['lockHashKeyWords'];
        // Make certain that NO user is set initially
        $this->user = null;
        // Set all possible headers that could ensure that the script is not cached on the client-side
        if ($this->sendNoCacheHeaders && !(TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI)) {
            header('Expires: 0');
            header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
            $cacheControlHeader = 'no-cache, must-revalidate';
            $pragmaHeader = 'no-cache';
            // Prevent error message in IE when using a https connection
            // see http://forge.typo3.org/issues/24125
            $clientInfo = GeneralUtility::clientInfo();
            if ($clientInfo['BROWSER'] === 'msie' && GeneralUtility::getIndpEnv('TYPO3_SSL')) {
                // Some IEs can not handle no-cache
                // see http://support.microsoft.com/kb/323308/en-us
                $cacheControlHeader = 'must-revalidate';
                // IE needs "Pragma: private" if SSL connection
                $pragmaHeader = 'private';
            }
            header('Cache-Control: ' . $cacheControlHeader);
            header('Pragma: ' . $pragmaHeader);
        }
        // Load user session, check to see if anyone has submitted login-information and if so authenticate
        // the user with the session. $this->user[uid] may be used to write log...
        $this->checkAuthentication();
        // Setting cookies
        if (!$this->dontSetCookie) {
            $this->setSessionCookie();
        }
        // Hook for alternative ways of filling the $this->user array (is used by the "timtaw" extension)
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['postUserLookUp'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['postUserLookUp'] as $funcName) {
                $_params = [
                    'pObj' => &$this
                ];
                GeneralUtility::callUserFunction($funcName, $_params, $this);
            }
        }
        // Set $this->gc_time if not explicitly specified
        if ($this->gc_time == 0) {
            // Default to 1 day if $this->auth_timeout_field is 0
            $this->gc_time = $this->auth_timeout_field == 0 ? 86400 : $this->auth_timeout_field;
        }
        // If we're lucky we'll get to clean up old sessions....
        if (rand() % 100 <= $this->gc_probability) {
            $this->gc();
        }
    }

    protected function setSessionCookie()
    {
        $isSetSessionCookie = $this->isSetSessionCookie();
        $isRefreshTimeBasedCookie = $this->isRefreshTimeBasedCookie();
        if ($isSetSessionCookie || $isRefreshTimeBasedCookie) {
            $settings = $GLOBALS['TYPO3_CONF_VARS']['SYS'];
            // Get the domain to be used for the cookie (if any):
            $cookieDomain = $this->getCookieDomain();
            // If no cookie domain is set, use the base path:
            $cookiePath = $cookieDomain ? '/' : GeneralUtility::getIndpEnv('TYPO3_SITE_PATH');
            // If the cookie lifetime is set, use it:
            $cookieExpire = $isRefreshTimeBasedCookie ? $GLOBALS['EXEC_TIME'] + $this->lifetime : 0;
            // Use the secure option when the current request is served by a secure connection:
            $cookieSecure = (bool)$settings['cookieSecure'] && GeneralUtility::getIndpEnv('TYPO3_SSL');
            // Deliver cookies only via HTTP and prevent possible XSS by JavaScript:
            $cookieHttpOnly = (bool)$settings['cookieHttpOnly'];
            // Do not set cookie if cookieSecure is set to "1" (force HTTPS) and no secure channel is used:
            if ((int)$settings['cookieSecure'] !== 1 || GeneralUtility::getIndpEnv('TYPO3_SSL')) {
                setcookie($this->name, $this->id, $cookieExpire, $cookiePath, $cookieDomain, $cookieSecure, $cookieHttpOnly);
                $this->cookieWasSetOnCurrentRequest = true;
            } else {
                throw new \TYPO3\CMS\Core\Exception('Cookie was not set since HTTPS was forced in $TYPO3_CONF_VARS[SYS][cookieSecure].', 1254325546);
            }
            if ($this->writeDevLog) {
                $devLogMessage = ($isRefreshTimeBasedCookie ? 'Updated Cookie: ' : 'Set Cookie: ') . $this->id;
                GeneralUtility::devLog($devLogMessage . ($cookieDomain ? ', ' . $cookieDomain : ''), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
        }
    }

    protected function getCookieDomain()
    {
        $result = '';
        $cookieDomain = $GLOBALS['TYPO3_CONF_VARS']['SYS']['cookieDomain'];
        // If a specific cookie domain is defined for a given TYPO3_MODE,
        // use that domain
        if (!empty($GLOBALS['TYPO3_CONF_VARS'][$this->loginType]['cookieDomain'])) {
            $cookieDomain = $GLOBALS['TYPO3_CONF_VARS'][$this->loginType]['cookieDomain'];
        }
        if ($cookieDomain) {
            if ($cookieDomain[0] == '/') {
                $match = [];
                $matchCnt = @preg_match($cookieDomain, GeneralUtility::getIndpEnv('TYPO3_HOST_ONLY'), $match);
                if ($matchCnt === false) {
                    GeneralUtility::sysLog('The regular expression for the cookie domain (' . $cookieDomain . ') contains errors. The session is not shared across sub-domains.', 'core', GeneralUtility::SYSLOG_SEVERITY_ERROR);
                } elseif ($matchCnt) {
                    $result = $match[0];
                }
            } else {
                $result = $cookieDomain;
            }
        }
        return $result;
    }

    protected function getCookie($cookieName)
    {
        return isset($_COOKIE[$cookieName]) ? stripslashes($_COOKIE[$cookieName]) : '';
    }

    public function isSetSessionCookie()
    {
        return ($this->newSessionID || $this->forceSetCookie) && $this->lifetime == 0;
    }

    public function isRefreshTimeBasedCookie()
    {
        return $this->lifetime > 0;
    }

    public function checkAuthentication()
    {
        // No user for now - will be searched by service below
        $tempuserArr = [];
        $tempuser = false;
        // User is not authenticated by default
        $authenticated = false;
        // User want to login with passed login data (name/password)
        $activeLogin = false;
        // Indicates if an active authentication failed (not auto login)
        $this->loginFailure = false;
        if ($this->writeDevLog) {
            GeneralUtility::devLog('Login type: ' . $this->loginType, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        // The info array provide additional information for auth services
        $authInfo = $this->getAuthInfoArray();
        // Get Login/Logout data submitted by a form or params
        $loginData = $this->getLoginFormData();
        if ($this->writeDevLog) {
            GeneralUtility::devLog('Login data: ' . GeneralUtility::arrayToLogString($loginData), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        // Active logout (eg. with "logout" button)
        if ($loginData['status'] === 'logout') {
            if ($this->writeStdLog) {
                // $type,$action,$error,$details_nr,$details,$data,$tablename,$recuid,$recpid
                $this->writelog(255, 2, 0, 2, 'User %s logged out', [$this->user['username']], '', 0, 0);
            }
            // Logout written to log
            if ($this->writeDevLog) {
                GeneralUtility::devLog('User logged out. Id: ' . $this->id, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, -1);
            }
            $this->logoff();
        }
        // Determine whether we need to skip session update.
        // This is used mainly for checking session timeout in advance without refreshing the current session's timeout.
        $skipSessionUpdate = (bool)GeneralUtility::_GP('skipSessionUpdate');
        $haveSession = false;
        if (!$this->newSessionID) {
            // Read user session
            $authInfo['userSession'] = $this->fetchUserSession($skipSessionUpdate);
            $haveSession = is_array($authInfo['userSession']);
        }
        // Active login (eg. with login form)
        if (!$haveSession && $loginData['status'] === 'login') {
            $activeLogin = true;
            if ($this->writeDevLog) {
                GeneralUtility::devLog('Active login (eg. with login form)', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
            // check referer for submitted login values
            if ($this->formfield_status && $loginData['uident'] && $loginData['uname']) {
                // Delete old user session if any
                $this->logoff();
            }
            // Refuse login for _CLI users, if not processing a CLI request type
            // (although we shouldn't be here in case of a CLI request type)
            if (strtoupper(substr($loginData['uname'], 0, 5)) == '_CLI_' && !(TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI)) {
                throw new \RuntimeException('TYPO3 Fatal Error: You have tried to login using a CLI user. Access prohibited!', 1270853931);
            }
        }
        if ($this->writeDevLog) {
            if ($haveSession) {
                GeneralUtility::devLog('User session found: ' . GeneralUtility::arrayToLogString($authInfo['userSession'], [$this->userid_column, $this->username_column]), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 0);
            } else {
                GeneralUtility::devLog('No user session found.', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 2);
            }
            if (is_array($this->svConfig['setup'])) {
                GeneralUtility::devLog('SV setup: ' . GeneralUtility::arrayToLogString($this->svConfig['setup']), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 0);
            }
        }
        // Fetch user if ...
        if (
            $activeLogin || $this->svConfig['setup'][$this->loginType . '_alwaysFetchUser']
            || !$haveSession && $this->svConfig['setup'][$this->loginType . '_fetchUserIfNoSession']
        ) {
            // Use 'auth' service to find the user
            // First found user will be used
            $serviceChain = '';
            $subType = 'getUser' . $this->loginType;
            while (is_object($serviceObj = GeneralUtility::makeInstanceService('auth', $subType, $serviceChain))) {
                $serviceChain .= ',' . $serviceObj->getServiceKey();
                $serviceObj->initAuth($subType, $loginData, $authInfo, $this);
                if ($row = $serviceObj->getUser()) {
                    $tempuserArr[] = $row;
                    if ($this->writeDevLog) {
                        GeneralUtility::devLog('User found: ' . GeneralUtility::arrayToLogString($row, [$this->userid_column, $this->username_column]), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 0);
                    }
                    // User found, just stop to search for more if not configured to go on
                    if (!$this->svConfig['setup'][$this->loginType . '_fetchAllUsers']) {
                        break;
                    }
                }
                unset($serviceObj);
            }
            unset($serviceObj);
            if ($this->writeDevLog && $this->svConfig['setup'][$this->loginType . '_alwaysFetchUser']) {
                GeneralUtility::devLog($this->loginType . '_alwaysFetchUser option is enabled', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
            if ($this->writeDevLog && $serviceChain) {
                GeneralUtility::devLog($subType . ' auth services called: ' . $serviceChain, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
            if ($this->writeDevLog && empty($tempuserArr)) {
                GeneralUtility::devLog('No user found by services', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
            if ($this->writeDevLog && !empty($tempuserArr)) {
                GeneralUtility::devLog(count($tempuserArr) . ' user records found by services', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
        }
        // If no new user was set we use the already found user session
        if (empty($tempuserArr) && $haveSession) {
            $tempuserArr[] = $authInfo['userSession'];
            $tempuser = $authInfo['userSession'];
            // User is authenticated because we found a user session
            $authenticated = true;
            if ($this->writeDevLog) {
                GeneralUtility::devLog('User session used: ' . GeneralUtility::arrayToLogString($authInfo['userSession'], [$this->userid_column, $this->username_column]), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
        }
        // Re-auth user when 'auth'-service option is set
        if ($this->svConfig['setup'][$this->loginType . '_alwaysAuthUser']) {
            $authenticated = false;
            if ($this->writeDevLog) {
                GeneralUtility::devLog('alwaysAuthUser option is enabled', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
        }
        // Authenticate the user if needed
        if (!empty($tempuserArr) && !$authenticated) {
            foreach ($tempuserArr as $tempuser) {
                // Use 'auth' service to authenticate the user
                // If one service returns FALSE then authentication failed
                // a service might return 100 which means there's no reason to stop but the user can't be authenticated by that service
                if ($this->writeDevLog) {
                    GeneralUtility::devLog('Auth user: ' . GeneralUtility::arrayToLogString($tempuser), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
                }
                $serviceChain = '';
                $subType = 'authUser' . $this->loginType;
                while (is_object($serviceObj = GeneralUtility::makeInstanceService('auth', $subType, $serviceChain))) {
                    $serviceChain .= ',' . $serviceObj->getServiceKey();
                    $serviceObj->initAuth($subType, $loginData, $authInfo, $this);
                    if (($ret = $serviceObj->authUser($tempuser)) > 0) {
                        // If the service returns >=200 then no more checking is needed - useful for IP checking without password
                        if ((int)$ret >= 200) {
                            $authenticated = true;
                            break;
                        } elseif ((int)$ret >= 100) {
                        } else {
                            $authenticated = true;
                        }
                    } else {
                        $authenticated = false;
                        break;
                    }
                    unset($serviceObj);
                }
                unset($serviceObj);
                if ($this->writeDevLog && $serviceChain) {
                    GeneralUtility::devLog($subType . ' auth services called: ' . $serviceChain, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
                }
                if ($authenticated) {
                    // Leave foreach() because a user is authenticated
                    break;
                }
            }
        }
        // If user is authenticated a valid user is in $tempuser
        if ($authenticated) {
            // Reset failure flag
            $this->loginFailure = false;
            // Insert session record if needed:
            if (!($haveSession && ($tempuser['ses_id'] == $this->id || $tempuser['uid'] == $authInfo['userSession']['ses_userid']))) {
                $sessionData = $this->createUserSession($tempuser);
                if ($sessionData) {
                    $this->user = array_merge(
                        $tempuser,
                        $sessionData
                    );
                }
                // The login session is started.
                $this->loginSessionStarted = true;
                if ($this->writeDevLog && is_array($this->user)) {
                    GeneralUtility::devLog('User session finally read: ' . GeneralUtility::arrayToLogString($this->user, [$this->userid_column, $this->username_column]), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, -1);
                }
            } elseif ($haveSession) {
                $this->user = $authInfo['userSession'];
            }
            if ($activeLogin && !$this->newSessionID) {
                $this->regenerateSessionId();
            }
            // User logged in - write that to the log!
            if ($this->writeStdLog && $activeLogin) {
                $this->writelog(255, 1, 0, 1, 'User %s logged in from %s (%s)', [$tempuser[$this->username_column], GeneralUtility::getIndpEnv('REMOTE_ADDR'), GeneralUtility::getIndpEnv('REMOTE_HOST')], '', '', '', -1, '', $tempuser['uid']);
            }
            if ($this->writeDevLog && $activeLogin) {
                GeneralUtility::devLog('User ' . $tempuser[$this->username_column] . ' logged in from ' . GeneralUtility::getIndpEnv('REMOTE_ADDR') . ' (' . GeneralUtility::getIndpEnv('REMOTE_HOST') . ')', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, -1);
            }
            if ($this->writeDevLog && !$activeLogin) {
                GeneralUtility::devLog('User ' . $tempuser[$this->username_column] . ' authenticated from ' . GeneralUtility::getIndpEnv('REMOTE_ADDR') . ' (' . GeneralUtility::getIndpEnv('REMOTE_HOST') . ')', \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, -1);
            }
        } elseif ($activeLogin || !empty($tempuserArr)) {
            $this->loginFailure = true;
            if ($this->writeDevLog && empty($tempuserArr) && $activeLogin) {
                GeneralUtility::devLog('Login failed: ' . GeneralUtility::arrayToLogString($loginData), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 2);
            }
            if ($this->writeDevLog && !empty($tempuserArr)) {
                GeneralUtility::devLog('Login failed: ' . GeneralUtility::arrayToLogString($tempuser, [$this->userid_column, $this->username_column]), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 2);
            }
        }
        // If there were a login failure, check to see if a warning email should be sent:
        if ($this->loginFailure && $activeLogin) {
            if ($this->writeDevLog) {
                GeneralUtility::devLog('Call checkLogFailures: ' . GeneralUtility::arrayToLogString(['warningEmail' => $this->warningEmail, 'warningPeriod' => $this->warningPeriod, 'warningMax' => $this->warningMax]), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, -1);
            }

            // Hook to implement login failure tracking methods
            if (
                !empty($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['postLoginFailureProcessing'])
                && is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['postLoginFailureProcessing'])
            ) {
                $_params = [];
                foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['postLoginFailureProcessing'] as $_funcRef) {
                    GeneralUtility::callUserFunction($_funcRef, $_params, $this);
                }
            } else {
                // If no hook is implemented, wait for 5 seconds
                sleep(5);
            }

            $this->checkLogFailures($this->warningEmail, $this->warningPeriod, $this->warningMax);
        }
    }

    public function createSessionId()
    {
        return GeneralUtility::getRandomHexString($this->hash_length);
    }

    protected function regenerateSessionId()
    {
        $oldSessionId = $this->id;
        $this->id = $this->createSessionId();
        // Update session record with new ID
        $this->db->exec_UPDATEquery(
            $this->session_table,
            'ses_id = ' . $this->db->fullQuoteStr($oldSessionId, $this->session_table)
                . ' AND ses_name = ' . $this->db->fullQuoteStr($this->name, $this->session_table),
            ['ses_id' => $this->id]
        );
        $this->user['ses_id'] = $this->id;
        $this->newSessionID = true;
    }

    /*************************
     *
     * User Sessions
     *
     *************************/
    public function createUserSession($tempuser)
    {
        if ($this->writeDevLog) {
            GeneralUtility::devLog('Create session ses_id = ' . $this->id, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        // Delete session entry first
        $this->db->exec_DELETEquery(
            $this->session_table,
            'ses_id = ' . $this->db->fullQuoteStr($this->id, $this->session_table)
                . ' AND ses_name = ' . $this->db->fullQuoteStr($this->name, $this->session_table)
        );
        // Re-create session entry
        $insertFields = $this->getNewSessionRecord($tempuser);
        $inserted = (bool)$this->db->exec_INSERTquery($this->session_table, $insertFields);
        if (!$inserted) {
            $message = 'Session data could not be written to DB. Error: ' . $this->db->sql_error();
            GeneralUtility::sysLog($message, 'core', GeneralUtility::SYSLOG_SEVERITY_WARNING);
            if ($this->writeDevLog) {
                GeneralUtility::devLog($message, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class, 2);
            }
        }
        // Updating lastLogin_column carrying information about last login.
        if ($this->lastLogin_column && $inserted) {
            $this->db->exec_UPDATEquery(
                $this->user_table,
                $this->userid_column . '=' . $this->db->fullQuoteStr($tempuser[$this->userid_column], $this->user_table),
                [$this->lastLogin_column => $GLOBALS['EXEC_TIME']]
            );
        }

        return $inserted ? $insertFields : [];
    }

    public function getNewSessionRecord($tempuser)
    {
        $sessionIpLock = '[DISABLED]';
        if ($this->lockIP && empty($tempuser['disableIPlock'])) {
            $sessionIpLock = $this->ipLockClause_remoteIPNumber($this->lockIP);
        }

        return [
            'ses_id' => $this->id,
            'ses_name' => $this->name,
            'ses_iplock' => $sessionIpLock,
            'ses_hashlock' => $this->hashLockClause_getHashInt(),
            'ses_userid' => $tempuser[$this->userid_column],
            'ses_tstamp' => $GLOBALS['EXEC_TIME'],
            'ses_data' => ''
        ];
    }

    public function fetchUserSession($skipSessionUpdate = false)
    {
        $user = false;
        if ($this->writeDevLog) {
            GeneralUtility::devLog('Fetch session ses_id = ' . $this->id, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }

        // Fetch the user session from the DB
        $statement = $this->fetchUserSessionFromDB();

        if ($statement) {
            $statement->execute();
            $user = $statement->fetch();
            $statement->free();
        }
        if ($user) {
            // A user was found
            if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($this->auth_timeout_field)) {
                // Get timeout from object
                $timeout = (int)$this->auth_timeout_field;
            } else {
                // Get timeout-time from usertable
                $timeout = (int)$user[$this->auth_timeout_field];
            }
            // If timeout > 0 (TRUE) and current time has not exceeded the latest sessions-time plus the timeout in seconds then accept user
            // Use a gracetime-value to avoid updating a session-record too often
            if ($timeout > 0 && $GLOBALS['EXEC_TIME'] < $user['ses_tstamp'] + $timeout) {
                $sessionUpdateGracePeriod = 61;
                if (!$skipSessionUpdate && $GLOBALS['EXEC_TIME'] > ($user['ses_tstamp'] + $sessionUpdateGracePeriod)) {
                    $this->db->exec_UPDATEquery($this->session_table, 'ses_id=' . $this->db->fullQuoteStr($this->id, $this->session_table)
                        . ' AND ses_name=' . $this->db->fullQuoteStr($this->name, $this->session_table), ['ses_tstamp' => $GLOBALS['EXEC_TIME']]);
                    // Make sure that the timestamp is also updated in the array
                    $user['ses_tstamp'] = $GLOBALS['EXEC_TIME'];
                }
            } else {
                // Delete any user set...
                $this->logoff();
                $user = false;
            }
        }
        return $user;
    }

    public function logoff()
    {
        if ($this->writeDevLog) {
            GeneralUtility::devLog('logoff: ses_id = ' . $this->id, \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        // Release the locked records
        \TYPO3\CMS\Backend\Utility\BackendUtility::lockRecords();
        // Hook for pre-processing the logoff() method, requested and implemented by andreas.otto@dkd.de:
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['logoff_pre_processing'])) {
            $_params = [];
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['logoff_pre_processing'] as $_funcRef) {
                if ($_funcRef) {
                    GeneralUtility::callUserFunction($_funcRef, $_params, $this);
                }
            }
        }
        $this->db->exec_DELETEquery($this->session_table, 'ses_id = ' . $this->db->fullQuoteStr($this->id, $this->session_table) . '
                        AND ses_name = ' . $this->db->fullQuoteStr($this->name, $this->session_table));
        $this->user = null;
        // Hook for post-processing the logoff() method, requested and implemented by andreas.otto@dkd.de:
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['logoff_post_processing'])) {
            $_params = [];
            foreach ($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['t3lib/class.t3lib_userauth.php']['logoff_post_processing'] as $_funcRef) {
                if ($_funcRef) {
                    GeneralUtility::callUserFunction($_funcRef, $_params, $this);
                }
            }
        }
    }

    public function removeCookie($cookieName)
    {
        $cookieDomain = $this->getCookieDomain();
        // If no cookie domain is set, use the base path
        $cookiePath = $cookieDomain ? '/' : GeneralUtility::getIndpEnv('TYPO3_SITE_PATH');
        setcookie($cookieName, null, -1, $cookiePath, $cookieDomain);
    }

    public function isExistingSessionRecord($id)
    {
        $statement = $this->db->prepare_SELECTquery('COUNT(*)', $this->session_table, 'ses_id = :ses_id');
        $statement->execute([':ses_id' => $id]);
        $row = $statement->fetch(\TYPO3\CMS\Core\Database\PreparedStatement::FETCH_NUM);
        $statement->free();
        return (bool)$row[0];
    }

    public function isCookieSet()
    {
        return $this->cookieWasSetOnCurrentRequest || $this->getCookie($this->name);
    }

    /*************************
     *
     * SQL Functions
     *
     *************************/
    protected function fetchUserSessionFromDB()
    {
        $statement = null;
        $ipLockClause = $this->ipLockClause();
        $statement = $this->db->prepare_SELECTquery('*', $this->session_table . ',' . $this->user_table, $this->session_table . '.ses_id = :ses_id
                    AND ' . $this->session_table . '.ses_name = :ses_name
                    AND ' . $this->session_table . '.ses_userid = ' . $this->user_table . '.' . $this->userid_column . '
                    ' . $ipLockClause['where'] . '
                    ' . $this->hashLockClause() . '
                    ' . $this->user_where_clause());
        $statement->bindValues([
                ':ses_id' => $this->id,
                ':ses_name' => $this->name
            ]);
        $statement->bindValues($ipLockClause['parameters']);
        return $statement;
    }

    protected function user_where_clause()
    {
        $whereClause = '';
        if ($this->enablecolumns['rootLevel']) {
            $whereClause .= 'AND ' . $this->user_table . '.pid=0 ';
        }
        if ($this->enablecolumns['disabled']) {
            $whereClause .= ' AND ' . $this->user_table . '.' . $this->enablecolumns['disabled'] . '=0';
        }
        if ($this->enablecolumns['deleted']) {
            $whereClause .= ' AND ' . $this->user_table . '.' . $this->enablecolumns['deleted'] . '=0';
        }
        if ($this->enablecolumns['starttime']) {
            $whereClause .= ' AND (' . $this->user_table . '.' . $this->enablecolumns['starttime'] . '<=' . $GLOBALS['EXEC_TIME'] . ')';
        }
        if ($this->enablecolumns['endtime']) {
            $whereClause .= ' AND (' . $this->user_table . '.' . $this->enablecolumns['endtime'] . '=0 OR '
                . $this->user_table . '.' . $this->enablecolumns['endtime'] . '>' . $GLOBALS['EXEC_TIME'] . ')';
        }
        return $whereClause;
    }

    protected function ipLockClause()
    {
        $statementClause = [
            'where' => '',
            'parameters' => []
        ];
        if ($this->lockIP) {
            $statementClause['where'] = 'AND (
                ' . $this->session_table . '.ses_iplock = :ses_iplock
                OR ' . $this->session_table . '.ses_iplock=\'[DISABLED]\'
                )';
            $statementClause['parameters'] = [
                ':ses_iplock' => $this->ipLockClause_remoteIPNumber($this->lockIP)
            ];
        }
        return $statementClause;
    }

    protected function ipLockClause_remoteIPNumber($parts)
    {
        $IP = GeneralUtility::getIndpEnv('REMOTE_ADDR');
        if ($parts >= 4) {
            return $IP;
        } else {
            $parts = \TYPO3\CMS\Core\Utility\MathUtility::forceIntegerInRange($parts, 1, 3);
            $IPparts = explode('.', $IP);
            for ($a = 4; $a > $parts; $a--) {
                unset($IPparts[$a - 1]);
            }
            return implode('.', $IPparts);
        }
    }

    public function veriCode()
    {
        return substr(md5($this->id . $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey']), 0, 10);
    }

    protected function hashLockClause()
    {
        return 'AND ' . $this->session_table . '.ses_hashlock=' . $this->hashLockClause_getHashInt();
    }

    protected function hashLockClause_getHashInt()
    {
        $hashStr = '';
        if (GeneralUtility::inList($this->lockHashKeyWords, 'useragent')) {
            $hashStr .= ':' . GeneralUtility::getIndpEnv('HTTP_USER_AGENT');
        }
        return GeneralUtility::md5int($hashStr);
    }

    /*************************
     *
     * Session and Configuration Handling
     *
     *************************/
    public function writeUC($variable = '')
    {
        if (is_array($this->user) && $this->user[$this->userid_column]) {
            if (!is_array($variable)) {
                $variable = $this->uc;
            }
            if ($this->writeDevLog) {
                GeneralUtility::devLog('writeUC: ' . $this->userid_column . '=' . (int)$this->user[$this->userid_column], \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
            $this->db->exec_UPDATEquery($this->user_table, $this->userid_column . '=' . (int)$this->user[$this->userid_column], ['uc' => serialize($variable)]);
        }
    }

    public function unpack_uc($theUC = '')
    {
        if (!$theUC && isset($this->user['uc'])) {
            $theUC = unserialize($this->user['uc']);
        }
        if (is_array($theUC)) {
            $this->uc = $theUC;
        }
    }

    public function pushModuleData($module, $data, $noSave = 0)
    {
        $this->uc['moduleData'][$module] = $data;
        $this->uc['moduleSessionID'][$module] = $this->id;
        if (!$noSave) {
            $this->writeUC();
        }
    }

    public function getModuleData($module, $type = '')
    {
        if ($type != 'ses' || (isset($this->uc['moduleSessionID'][$module]) && $this->uc['moduleSessionID'][$module] == $this->id)) {
            return $this->uc['moduleData'][$module];
        }
        return null;
    }

    public function getSessionData($key)
    {
        $sesDat = unserialize($this->user['ses_data']);
        return $sesDat[$key];
    }

    public function setAndSaveSessionData($key, $data)
    {
        $sesDat = unserialize($this->user['ses_data']);
        $sesDat[$key] = $data;
        $this->user['ses_data'] = serialize($sesDat);
        if ($this->writeDevLog) {
            GeneralUtility::devLog('setAndSaveSessionData: ses_id = ' . $this->user['ses_id'], \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        $this->db->exec_UPDATEquery($this->session_table, 'ses_id=' . $this->db->fullQuoteStr($this->user['ses_id'], $this->session_table), ['ses_data' => $this->user['ses_data']]);
    }

    /*************************
     *
     * Misc
     *
     *************************/
    public function getLoginFormData()
    {
        $loginData = [];
        $loginData['status'] = GeneralUtility::_GP($this->formfield_status);
        if ($this->getMethodEnabled) {
            $loginData['uname'] = GeneralUtility::_GP($this->formfield_uname);
            $loginData['uident'] = GeneralUtility::_GP($this->formfield_uident);
        } else {
            $loginData['uname'] = GeneralUtility::_POST($this->formfield_uname);
            $loginData['uident'] = GeneralUtility::_POST($this->formfield_uident);
        }
        // Only process the login data if a login is requested
        if ($loginData['status'] === 'login') {
            $loginData = $this->processLoginData($loginData);
        }
        $loginData = array_map('trim', $loginData);
        return $loginData;
    }

    public function processLoginData($loginData, $passwordTransmissionStrategy = '')
    {
        $loginSecurityLevel = trim($GLOBALS['TYPO3_CONF_VARS'][$this->loginType]['loginSecurityLevel']) ?: 'normal';
        $passwordTransmissionStrategy = $passwordTransmissionStrategy ?: $loginSecurityLevel;
        if ($this->writeDevLog) {
            GeneralUtility::devLog('Login data before processing: ' . GeneralUtility::arrayToLogString($loginData), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
        }
        $serviceChain = '';
        $subType = 'processLoginData' . $this->loginType;
        $authInfo = $this->getAuthInfoArray();
        $isLoginDataProcessed = false;
        $processedLoginData = $loginData;
        while (is_object($serviceObject = GeneralUtility::makeInstanceService('auth', $subType, $serviceChain))) {
            $serviceChain .= ',' . $serviceObject->getServiceKey();
            $serviceObject->initAuth($subType, $loginData, $authInfo, $this);
            $serviceResult = $serviceObject->processLoginData($processedLoginData, $passwordTransmissionStrategy);
            if (!empty($serviceResult)) {
                $isLoginDataProcessed = true;
                // If the service returns >=200 then no more processing is needed
                if ((int)$serviceResult >= 200) {
                    unset($serviceObject);
                    break;
                }
            }
            unset($serviceObject);
        }
        if ($isLoginDataProcessed) {
            $loginData = $processedLoginData;
            if ($this->writeDevLog) {
                GeneralUtility::devLog('Processed login data: ' . GeneralUtility::arrayToLogString($processedLoginData), \TYPO3\CMS\Core\Authentication\AbstractUserAuthentication::class);
            }
        }
        return $loginData;
    }

    public function getAuthInfoArray()
    {
        $authInfo = [];
        $authInfo['loginType'] = $this->loginType;
        $authInfo['refInfo'] = parse_url(GeneralUtility::getIndpEnv('HTTP_REFERER'));
        $authInfo['HTTP_HOST'] = GeneralUtility::getIndpEnv('HTTP_HOST');
        $authInfo['REMOTE_ADDR'] = GeneralUtility::getIndpEnv('REMOTE_ADDR');
        $authInfo['REMOTE_HOST'] = GeneralUtility::getIndpEnv('REMOTE_HOST');
        $authInfo['showHiddenRecords'] = $this->showHiddenRecords;
        // Can be overidden in localconf by SVCONF:
        $authInfo['db_user']['table'] = $this->user_table;
        $authInfo['db_user']['userid_column'] = $this->userid_column;
        $authInfo['db_user']['username_column'] = $this->username_column;
        $authInfo['db_user']['userident_column'] = $this->userident_column;
        $authInfo['db_user']['usergroup_column'] = $this->usergroup_column;
        $authInfo['db_user']['enable_clause'] = $this->user_where_clause();
        if ($this->checkPid && $this->checkPid_value !== null) {
            $authInfo['db_user']['checkPidList'] = $this->checkPid_value;
            $authInfo['db_user']['check_pid_clause'] = ' AND pid IN (' .
                $this->db->cleanIntList($this->checkPid_value) . ')';
        } else {
            $authInfo['db_user']['checkPidList'] = '';
            $authInfo['db_user']['check_pid_clause'] = '';
        }
        $authInfo['db_groups']['table'] = $this->usergroup_table;
        return $authInfo;
    }

    public function compareUident($user, $loginData, $passwordCompareStrategy = '')
    {
        return (string)$loginData['uident_text'] !== '' && (string)$loginData['uident_text'] === (string)$user[$this->userident_column];
    }

    public function gc()
    {
        $this->db->exec_DELETEquery($this->session_table, 'ses_tstamp < ' . (int)($GLOBALS['EXEC_TIME'] - $this->gc_time) . ' AND ses_name = ' . $this->db->fullQuoteStr($this->name, $this->session_table));
    }

    public function writelog($type, $action, $error, $details_nr, $details, $data, $tablename, $recuid, $recpid)
    {
    }

    public function checkLogFailures($email, $secondsBack, $maxFailures)
    {
    }

    public function setBeUserByUid($uid)
    {
        $this->user = $this->getRawUserByUid($uid);
    }

    public function setBeUserByName($name)
    {
        $this->user = $this->getRawUserByName($name);
    }

    public function getRawUserByUid($uid)
    {
        $user = false;
        $dbres = $this->db->exec_SELECTquery('*', $this->user_table, 'uid=' . (int)$uid . ' ' . $this->user_where_clause());
        if ($dbres) {
            $user = $this->db->sql_fetch_assoc($dbres);
            $this->db->sql_free_result($dbres);
        }
        return $user;
    }

    public function getRawUserByName($name)
    {
        $user = false;
        $dbres = $this->db->exec_SELECTquery('*', $this->user_table, 'username=' . $this->db->fullQuoteStr($name, $this->user_table) . ' ' . $this->user_where_clause());
        if ($dbres) {
            $user = $this->db->sql_fetch_assoc($dbres);
            $this->db->sql_free_result($dbres);
        }
        return $user;
    }

    /*************************
     *
     * Create/update user - EXPERIMENTAL
     *
     *************************/
    public function fetchUserRecord($dbUser, $username, $extraWhere = '')
    {
        $user = false;
        $usernameClause = $username ? $dbUser['username_column'] . '=' . $this->db->fullQuoteStr($username, $dbUser['table']) : '1=1';
        if ($username || $extraWhere) {
            // Look up the user by the username and/or extraWhere:
            $dbres = $this->db->exec_SELECTquery('*', $dbUser['table'], $usernameClause . $dbUser['check_pid_clause'] . $dbUser['enable_clause'] . $extraWhere);
            if ($dbres) {
                $user = $this->db->sql_fetch_assoc($dbres);
                $this->db->sql_free_result($dbres);
            }
        }
        return $user;
    }

    protected function getDatabaseConnection()
    {
        return $GLOBALS['TYPO3_DB'];
    }
}