LocalPasswordPrimaryAuthenticationProvider.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Auth;
 
use BadMethodCallException;
use MediaWiki\Deferred\DeferredUpdates;
use MediaWiki\MainConfigNames;
use MediaWiki\Password\InvalidPassword;
use MediaWiki\Status\Status;
use MediaWiki\User\UserRigorOptions;
use StatusValue;
use stdClass;
use Wikimedia\Rdbms\DBAccessObjectUtils;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDBAccessObject;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class LocalPasswordPrimaryAuthenticationProvider
    extends AbstractPasswordPrimaryAuthenticationProvider
{
 
    protected $loginOnly = false;
 
    private IConnectionProvider $dbProvider;
 
    public function __construct( IConnectionProvider $dbProvider, $params = [] ) {
        parent::__construct( $params );
        $this->loginOnly = !empty( $params['loginOnly'] );
        $this->dbProvider = $dbProvider;
    }
 
    protected function getPasswordResetData( $username, $row ) {
        $now = (int)wfTimestamp();
        $expiration = wfTimestampOrNull( TS::UNIX, $row->user_password_expires );
        if ( $expiration === null || (int)$expiration >= $now ) {
            return null;
        }
 
        $grace = $this->config->get( MainConfigNames::PasswordExpireGrace );
        if ( (int)$expiration + $grace < $now ) {
            $data = [
                'hard' => true,
                'msg' => Status::newFatal( 'resetpass-expired' )->getMessage(),
            ];
        } else {
            $data = [
                'hard' => false,
                'msg' => Status::newFatal( 'resetpass-expired-soft' )->getMessage(),
            ];
        }
 
        return (object)$data;
    }
 
    public function beginPrimaryAuthentication( array $reqs ) {
        $req = AuthenticationRequest::getRequestByClass( $reqs, PasswordAuthenticationRequest::class );
        if ( !$req || $req->username === null || $req->password === null ) {
            return AuthenticationResponse::newAbstain();
        }
 
        $username = $this->userNameUtils->getCanonical(
            $req->username, UserRigorOptions::RIGOR_USABLE );
        if ( $username === false ) {
            return AuthenticationResponse::newAbstain();
        }
 
        $row = $this->dbProvider->getReplicaDatabase()->newSelectQueryBuilder()
            ->select( [ 'user_id', 'user_password', 'user_password_expires' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->caller( __METHOD__ )->fetchRow();
        if ( !$row ) {
            // Do not reveal whether its bad username or
            // bad password to prevent username enumeration
            // on private wikis. (T134100)
            return $this->failResponse( $req );
        }
 
        $oldRow = clone $row;
        // Check for *really* old password hashes that don't even have a type
        // The old hash format was just an MD5 hex hash, with no type information
        if ( preg_match( '/^[0-9a-f]{32}$/', $row->user_password ) ) {
            $row->user_password = ":B:{$row->user_id}:{$row->user_password}";
        }
 
        $status = $this->checkPasswordValidity( $username, $req->password );
        if ( !$status->isOK() ) {
            return $this->getFatalPasswordErrorResponse( $username, $status );
        }
 
        $pwhash = $this->getPassword( $row->user_password );
        if ( !$pwhash->verify( $req->password ) ) {
            if ( $this->config->get( MainConfigNames::LegacyEncoding ) ) {
                // Some wikis were converted from ISO 8859-1 to UTF-8, the passwords can't be converted
                // Check for this with iconv
                $cp1252Password = iconv( 'UTF-8', 'WINDOWS-1252//TRANSLIT', $req->password );
                if ( $cp1252Password === $req->password || !$pwhash->verify( $cp1252Password ) ) {
                    return $this->failResponse( $req );
                }
            } else {
                return $this->failResponse( $req );
            }
        }
 
        // @codeCoverageIgnoreStart
        if ( $this->getPasswordFactory()->needsUpdate( $pwhash ) ) {
            $newHash = $this->getPasswordFactory()->newFromPlaintext( $req->password );
            DeferredUpdates::addCallableUpdate( function ( $fname ) use ( $newHash, $oldRow ) {
                $dbw = $this->dbProvider->getPrimaryDatabase();
                $dbw->newUpdateQueryBuilder()
                    ->update( 'user' )
                    ->set( [ 'user_password' => $newHash->toString() ] )
                    ->where( [
                        'user_id' => $oldRow->user_id,
                        'user_password' => $oldRow->user_password,
                    ] )
                    ->caller( $fname )
                    ->execute();
            } );
        }
        // @codeCoverageIgnoreEnd
 
        $this->setPasswordResetFlag( $username, $status, $row );
 
        return AuthenticationResponse::newPass( $username );
    }
 
    public function testUserCanAuthenticate( $username ) {
        $username = $this->userNameUtils->getCanonical(
            $username,
            UserRigorOptions::RIGOR_USABLE
        );
        if ( $username === false ) {
            return false;
        }
 
        $password = $this->dbProvider->getReplicaDatabase()->newSelectQueryBuilder()
            ->select( [ 'user_password' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->caller( __METHOD__ )
            ->fetchField();
        if ( $password === false ) {
            return false;
        }
 
        // Check for *really* old password hashes that don't even have a type
        // The old hash format was just an MD5 hex hash, with no type information
        if ( preg_match( '/^[0-9a-f]{32}$/', $password ) ) {
            return true;
        }
 
        return !$this->getPassword( $password ) instanceof InvalidPassword;
    }
 
    public function testUserExists( $username, $flags = IDBAccessObject::READ_NORMAL ) {
        $username = $this->userNameUtils->getCanonical(
            $username,
            UserRigorOptions::RIGOR_USABLE
        );
        if ( $username === false ) {
            return false;
        }
 
        $db = DBAccessObjectUtils::getDBFromRecency( $this->dbProvider, $flags );
        return (bool)$db->newSelectQueryBuilder()
            ->select( [ 'user_id' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->caller( __METHOD__ )->fetchField();
    }
 
    public function providerAllowsAuthenticationDataChange(
        AuthenticationRequest $req, $checkData = true
    ) {
        // We only want to blank the password if something else will accept the
        // new authentication data, so return 'ignore' here.
        if ( $this->loginOnly ) {
            return StatusValue::newGood( 'ignored' );
        }
 
        if ( get_class( $req ) === PasswordAuthenticationRequest::class ) {
            if ( !$checkData ) {
                return StatusValue::newGood();
            }
 
            $username = $this->userNameUtils->getCanonical( $req->username,
                UserRigorOptions::RIGOR_USABLE );
            if ( $username !== false ) {
                $row = $this->dbProvider->getPrimaryDatabase()->newSelectQueryBuilder()
                    ->select( [ 'user_id' ] )
                    ->from( 'user' )
                    ->where( [ 'user_name' => $username ] )
                    ->caller( __METHOD__ )->fetchRow();
                if ( $row ) {
                    $sv = StatusValue::newGood();
                    if ( $req->password !== null ) {
                        if ( $req->password !== $req->retype ) {
                            $sv->fatal( 'badretype' );
                        } else {
                            $sv->merge( $this->checkPasswordValidity( $username, $req->password ) );
                        }
                    }
                    return $sv;
                }
            }
        }
 
        return StatusValue::newGood( 'ignored' );
    }
 
    public function providerChangeAuthenticationData( AuthenticationRequest $req ) {
        $username = $req->username !== null
            ? $this->userNameUtils->getCanonical( $req->username, UserRigorOptions::RIGOR_USABLE )
            : false;
        if ( $username === false ) {
            return;
        }
 
        $pwhash = null;
 
        if ( get_class( $req ) === PasswordAuthenticationRequest::class ) {
            if ( $this->loginOnly ) {
                $pwhash = $this->getPasswordFactory()->newFromCiphertext( null );
                $expiry = null;
            } else {
                $pwhash = $this->getPasswordFactory()->newFromPlaintext( $req->password );
                $expiry = $this->getNewPasswordExpiry( $username );
            }
        }
 
        if ( $pwhash ) {
            $dbw = $this->dbProvider->getPrimaryDatabase();
            $dbw->newUpdateQueryBuilder()
                ->update( 'user' )
                ->set( [
                    'user_password' => $pwhash->toString(),
                    // @phan-suppress-next-line PhanPossiblyUndeclaredVariable expiry is set together with pwhash
                    'user_password_expires' => $dbw->timestampOrNull( $expiry ),
                ] )
                ->where( [ 'user_name' => $username ] )
                ->caller( __METHOD__ )->execute();
        }
    }
 
    public function accountCreationType() {
        return $this->loginOnly ? self::TYPE_NONE : self::TYPE_CREATE;
    }
 
    public function testForAccountCreation( $user, $creator, array $reqs ) {
        $req = AuthenticationRequest::getRequestByClass( $reqs, PasswordAuthenticationRequest::class );
 
        $ret = StatusValue::newGood();
        if ( !$this->loginOnly && $req && $req->username !== null && $req->password !== null ) {
            if ( $req->password !== $req->retype ) {
                $ret->fatal( 'badretype' );
            } else {
                $ret->merge(
                    $this->checkPasswordValidity( $user->getName(), $req->password )
                );
            }
        }
        return $ret;
    }
 
    public function beginPrimaryAccountCreation( $user, $creator, array $reqs ) {
        if ( $this->accountCreationType() === self::TYPE_NONE ) {
            throw new BadMethodCallException( 'Shouldn\'t call this when accountCreationType() is NONE' );
        }
 
        $req = AuthenticationRequest::getRequestByClass( $reqs, PasswordAuthenticationRequest::class );
        if ( $req && $req->username !== null && $req->password !== null ) {
            // Nothing we can do besides claim it, because the user isn't in
            // the DB yet
            if ( $req->username !== $user->getName() ) {
                $req = clone $req;
                $req->username = $user->getName();
            }
            $ret = AuthenticationResponse::newPass( $req->username );
            $ret->createRequest = $req;
            return $ret;
        }
        return AuthenticationResponse::newAbstain();
    }
 
    public function finishAccountCreation( $user, $creator, AuthenticationResponse $res ) {
        if ( $this->accountCreationType() === self::TYPE_NONE ) {
            throw new BadMethodCallException( 'Shouldn\'t call this when accountCreationType() is NONE' );
        }
 
        // Now that the user is in the DB, set the password on it.
        $this->providerChangeAuthenticationData( $res->createRequest );
 
        return null;
    }
}