CommandLineUserAuthentication.php

Go to the documentation of this file.

<?php
 
/*
 * 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!
 */
 
namespace ‪TYPO3\CMS\Core\Authentication;
 
use Psr\Http\Message\ServerRequestInterface;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Crypto\PasswordHashing\PasswordHashFactory;
use ‪TYPO3\CMS\Core\Crypto\Random;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DeletedRestriction;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
 
class ‪CommandLineUserAuthentication extends ‪BackendUserAuthentication
{
    protected ‪$username = '_cli_';
 
    public function ‪__construct()
    {
        if (!‪Environment::isCli()) {
            throw new \RuntimeException('Creating a CLI-based user object on non-CLI level is not allowed', 1483971165);
        }
        if (!$this->‪isUserAllowedToLogin()) {
            throw new \RuntimeException('Login Error: TYPO3 is in maintenance mode at the moment. Only administrators are allowed access.', 1483971855);
        }
        $this->dontSetCookie = true;
        parent::__construct();
    }
 
    public function ‪start(ServerRequestInterface $request = null)
    {
        // do nothing
    }
 
    public function ‪checkAuthentication(ServerRequestInterface $request = null)
    {
        // do nothing
    }
 
    public function ‪getOriginalUserIdWhenInSwitchUserMode(): ?int
    {
        return null;
    }
 
    public function ‪authenticate()
    {
        // check if a _CLI_ user exists, if not, create one
        $this->‪setBeUserByName($this->username);
        if (empty($this->user['uid'])) {
            // create a new BE user in the database
            if (!$this->‪checkIfCliUserExists()) {
                $this->‪createCliUser();
            } else {
                throw new \RuntimeException('No backend user named "_cli_" could be authenticated, maybe this user is "hidden"?', 1484050401);
            }
            $this->‪setBeUserByName($this->username);
        }
        if (empty($this->user['uid'])) {
            throw new \RuntimeException('No backend user named "_cli_" could be created.', 1476107195);
        }
        // The groups are fetched and ready for permission checking in this initialization.
        $this->‪fetchGroupData();
        $this->‪backendSetUC();
    }
 
    public function ‪backendCheckLogin($proceedIfNoUserIsLoggedIn = null)
    {
        $this->‪authenticate();
    }
 
    public function ‪isUserAllowedToLogin()
    {
        return in_array((int)‪$GLOBALS['TYPO3_CONF_VARS']['BE']['adminOnly'], [0, 2], true);
    }
 
    protected function ‪checkIfCliUserExists()
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('be_users');
        $queryBuilder->getRestrictions()
            ->removeAll()
            ->add(GeneralUtility::makeInstance(DeletedRestriction::class));
        $count = $queryBuilder
            ->count('*')
            ->from('be_users')
            ->where($queryBuilder->expr()->eq('username', $queryBuilder->createNamedParameter('_cli_')))
            ->executeQuery()
            ->fetchOne();
        return (bool)$count;
    }
 
    protected function ‪createCliUser()
    {
        $userFields = [
            'username' => ‪$this->username,
            'password' => $this->‪generateHashedPassword(),
            'admin'    => 1,
            'tstamp'   => ‪$GLOBALS['EXEC_TIME'] ?? time(),
            'crdate'   => ‪$GLOBALS['EXEC_TIME'] ?? time(),
        ];
 
        $databaseConnection = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable('be_users');
        $databaseConnection->insert('be_users', $userFields);
    }
 
    protected function ‪generateHashedPassword()
    {
        $cryptoService = GeneralUtility::makeInstance(Random::class);
        $password = $cryptoService->generateRandomBytes(20);
        $hashInstance = GeneralUtility::makeInstance(PasswordHashFactory::class)->getDefaultHashInstance('BE');
        return $hashInstance->getHashedPassword($password);
    }
}