TemporaryPasswordPrimaryAuthenticationProvider.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Auth;
 
use MediaWiki\MainConfigNames;
use MediaWiki\Title\Title;
use MediaWiki\User\UserOptionsLookup;
use MediaWiki\User\UserRigorOptions;
use SpecialPage;
use User;
use Wikimedia\IPUtils;
use Wikimedia\Rdbms\ILoadBalancer;
 
class TemporaryPasswordPrimaryAuthenticationProvider
    extends AbstractPasswordPrimaryAuthenticationProvider
{
    protected $emailEnabled = null;
 
    protected $newPasswordExpiry = null;
 
    protected $passwordReminderResendTime = null;
 
    protected $allowRequiringEmail = null;
 
    private $loadBalancer;
 
    private $userOptionsLookup;
 
    public function __construct(
        ILoadBalancer $loadBalancer,
        UserOptionsLookup $userOptionsLookup,
        $params = []
    ) {
        parent::__construct( $params );
 
        if ( isset( $params['emailEnabled'] ) ) {
            $this->emailEnabled = (bool)$params['emailEnabled'];
        }
        if ( isset( $params['newPasswordExpiry'] ) ) {
            $this->newPasswordExpiry = (int)$params['newPasswordExpiry'];
        }
        if ( isset( $params['passwordReminderResendTime'] ) ) {
            $this->passwordReminderResendTime = $params['passwordReminderResendTime'];
        }
        if ( isset( $params['allowRequiringEmailForResets'] ) ) {
            $this->allowRequiringEmail = $params['allowRequiringEmailForResets'];
        }
        $this->loadBalancer = $loadBalancer;
        $this->userOptionsLookup = $userOptionsLookup;
    }
 
    protected function postInitSetup() {
        $this->emailEnabled ??= $this->config->get( MainConfigNames::EnableEmail );
        $this->newPasswordExpiry ??= $this->config->get( MainConfigNames::NewPasswordExpiry );
        $this->passwordReminderResendTime ??=
            $this->config->get( MainConfigNames::PasswordReminderResendTime );
        $this->allowRequiringEmail ??=
            $this->config->get( MainConfigNames::AllowRequiringEmailForResets );
    }
 
    protected function getPasswordResetData( $username, $data ) {
        // Always reset
        return (object)[
            'msg' => wfMessage( 'resetpass-temp-emailed' ),
            'hard' => true,
        ];
    }
 
    public function getAuthenticationRequests( $action, array $options ) {
        switch ( $action ) {
            case AuthManager::ACTION_LOGIN:
                return [ new PasswordAuthenticationRequest() ];
 
            case AuthManager::ACTION_CHANGE:
                return [ TemporaryPasswordAuthenticationRequest::newRandom() ];
 
            case AuthManager::ACTION_CREATE:
                if ( isset( $options['username'] ) && $this->emailEnabled ) {
                    // Creating an account for someone else
                    return [ TemporaryPasswordAuthenticationRequest::newRandom() ];
                } else {
                    // It's not terribly likely that an anonymous user will
                    // be creating an account for someone else.
                    return [];
                }
 
            case AuthManager::ACTION_REMOVE:
                return [ new TemporaryPasswordAuthenticationRequest ];
 
            default:
                return [];
        }
    }
 
    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->loadBalancer->getConnection( DB_REPLICA )->newSelectQueryBuilder()
            ->select( [ 'user_id', 'user_newpassword', 'user_newpass_time' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->caller( __METHOD__ )->fetchRow();
        if ( !$row ) {
            return AuthenticationResponse::newAbstain();
        }
 
        $status = $this->checkPasswordValidity( $username, $req->password );
        if ( !$status->isOK() ) {
            // Fatal, can't log in
            return AuthenticationResponse::newFail( $status->getMessage() );
        }
 
        $pwhash = $this->getPassword( $row->user_newpassword );
        if ( !$pwhash->verify( $req->password ) ) {
            return $this->failResponse( $req );
        }
 
        if ( !$this->isTimestampValid( $row->user_newpass_time ) ) {
            return $this->failResponse( $req );
        }
 
        // Add an extra log entry since a temporary password is
        // an unusual way to log in, so its important to keep track
        // of in case of abuse.
        $this->logger->info( "{user} successfully logged in using temp password",
            [
                'user' => $username,
                'requestIP' => $this->manager->getRequest()->getIP()
            ]
        );
 
        $this->setPasswordResetFlag( $username, $status );
 
        return AuthenticationResponse::newPass( $username );
    }
 
    public function testUserCanAuthenticate( $username ) {
        $username = $this->userNameUtils->getCanonical( $username, UserRigorOptions::RIGOR_USABLE );
        if ( $username === false ) {
            return false;
        }
 
        $row = $this->loadBalancer->getConnection( DB_REPLICA )->newSelectQueryBuilder()
            ->select( [ 'user_newpassword', 'user_newpass_time' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->caller( __METHOD__ )->fetchRow();
        if ( !$row ) {
            return false;
        }
 
        if ( $this->getPassword( $row->user_newpassword ) instanceof \InvalidPassword ) {
            return false;
        }
 
        if ( !$this->isTimestampValid( $row->user_newpass_time ) ) {
            return false;
        }
 
        return true;
    }
 
    public function testUserExists( $username, $flags = User::READ_NORMAL ) {
        $username = $this->userNameUtils->getCanonical( $username, UserRigorOptions::RIGOR_USABLE );
        if ( $username === false ) {
            return false;
        }
 
        [ $db, $options ] = \DBAccessObjectUtils::getDBOptions( $flags );
        return (bool)$this->loadBalancer->getConnection( $db )->newSelectQueryBuilder()
            ->select( [ 'user_id' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->options( $options )
            ->caller( __METHOD__ )->fetchField();
    }
 
    public function providerAllowsAuthenticationDataChange(
        AuthenticationRequest $req, $checkData = true
    ) {
        if ( get_class( $req ) !== TemporaryPasswordAuthenticationRequest::class ) {
            // We don't really ignore it, but this is what the caller expects.
            return \StatusValue::newGood( 'ignored' );
        }
 
        if ( !$checkData ) {
            return \StatusValue::newGood();
        }
 
        $username = $this->userNameUtils->getCanonical(
            $req->username, UserRigorOptions::RIGOR_USABLE );
        if ( $username === false ) {
            return \StatusValue::newGood( 'ignored' );
        }
 
        $row = $this->loadBalancer->getConnection( DB_PRIMARY )->newSelectQueryBuilder()
            ->select( [ 'user_id', 'user_newpass_time' ] )
            ->from( 'user' )
            ->where( [ 'user_name' => $username ] )
            ->caller( __METHOD__ )->fetchRow();
        if ( !$row ) {
            return \StatusValue::newGood( 'ignored' );
        }
 
        $sv = \StatusValue::newGood();
        if ( $req->password !== null ) {
            $sv->merge( $this->checkPasswordValidity( $username, $req->password ) );
 
            if ( $req->mailpassword ) {
                if ( !$this->emailEnabled ) {
                    return \StatusValue::newFatal( 'passwordreset-emaildisabled' );
                }
 
                // We don't check whether the user has an email address;
                // that information should not be exposed to the caller.
 
                // do not allow temporary password creation within
                // $wgPasswordReminderResendTime from the last attempt
                if (
                    $this->passwordReminderResendTime
                    && $row->user_newpass_time
                    && time() < (int)wfTimestamp( TS_UNIX, $row->user_newpass_time )
                        + $this->passwordReminderResendTime * 3600
                ) {
                    // Round the time in hours to 3 d.p., in case someone is specifying
                    // minutes or seconds.
                    return \StatusValue::newFatal( 'throttled-mailpassword',
                        round( $this->passwordReminderResendTime, 3 ) );
                }
 
                if ( !$req->caller ) {
                    return \StatusValue::newFatal( 'passwordreset-nocaller' );
                }
                if ( !IPUtils::isValid( $req->caller ) ) {
                    $caller = User::newFromName( $req->caller );
                    if ( !$caller ) {
                        return \StatusValue::newFatal( 'passwordreset-nosuchcaller', $req->caller );
                    }
                }
            }
        }
        return $sv;
    }
 
    public function providerChangeAuthenticationData( AuthenticationRequest $req ) {
        $username = $req->username !== null ?
            $this->userNameUtils->getCanonical( $req->username, UserRigorOptions::RIGOR_USABLE ) : false;
        if ( $username === false ) {
            return;
        }
 
        $dbw = $this->loadBalancer->getConnectionRef( DB_PRIMARY );
 
        $sendMail = false;
        if ( $req->action !== AuthManager::ACTION_REMOVE &&
            get_class( $req ) === TemporaryPasswordAuthenticationRequest::class
        ) {
            $pwhash = $this->getPasswordFactory()->newFromPlaintext( $req->password );
            $newpassTime = $dbw->timestamp();
            $sendMail = $req->mailpassword;
        } else {
            // Invalidate the temporary password when any other auth is reset, or when removing
            $pwhash = $this->getPasswordFactory()->newFromCiphertext( null );
            $newpassTime = null;
        }
 
        $dbw->update(
            'user',
            [
                'user_newpassword' => $pwhash->toString(),
                'user_newpass_time' => $newpassTime,
            ],
            [ 'user_name' => $username ],
            __METHOD__
        );
 
        if ( $sendMail ) {
            // Send email after DB commit
            $dbw->onTransactionCommitOrIdle(
                function () use ( $req ) {
                    $this->sendPasswordResetEmail( $req );
                },
                __METHOD__
            );
        }
    }
 
    public function accountCreationType() {
        return self::TYPE_CREATE;
    }
 
    public function testForAccountCreation( $user, $creator, array $reqs ) {
        $req = AuthenticationRequest::getRequestByClass(
            $reqs, TemporaryPasswordAuthenticationRequest::class
        );
 
        $ret = \StatusValue::newGood();
        if ( $req ) {
            if ( $req->mailpassword ) {
                if ( !$this->emailEnabled ) {
                    $ret->merge( \StatusValue::newFatal( 'emaildisabled' ) );
                } elseif ( !$user->getEmail() ) {
                    $ret->merge( \StatusValue::newFatal( 'noemailcreate' ) );
                }
            }
 
            $ret->merge(
                $this->checkPasswordValidity( $user->getName(), $req->password )
            );
        }
        return $ret;
    }
 
    public function beginPrimaryAccountCreation( $user, $creator, array $reqs ) {
        $req = AuthenticationRequest::getRequestByClass(
            $reqs, TemporaryPasswordAuthenticationRequest::class
        );
        if ( $req && $req->username !== null && $req->password !== null ) {
            // Nothing we can do yet, because the user isn't in the DB yet
            if ( $req->username !== $user->getName() ) {
                $req = clone $req;
                $req->username = $user->getName();
            }
 
            if ( $req->mailpassword ) {
                // prevent EmailNotificationSecondaryAuthenticationProvider from sending another mail
                $this->manager->setAuthenticationSessionData( 'no-email', true );
            }
 
            $ret = AuthenticationResponse::newPass( $req->username );
            $ret->createRequest = $req;
            return $ret;
        }
        return AuthenticationResponse::newAbstain();
    }
 
    public function finishAccountCreation( $user, $creator, AuthenticationResponse $res ) {
        $req = $res->createRequest;
        $mailpassword = $req->mailpassword;
        $req->mailpassword = false; // providerChangeAuthenticationData would send the wrong email
 
        // Now that the user is in the DB, set the password on it.
        $this->providerChangeAuthenticationData( $req );
 
        if ( $mailpassword ) {
            // Send email after DB commit
            $this->loadBalancer->getConnectionRef( DB_PRIMARY )->onTransactionCommitOrIdle(
                function () use ( $user, $creator, $req ) {
                    $this->sendNewAccountEmail( $user, $creator, $req->password );
                },
                __METHOD__
            );
        }
 
        return $mailpassword ? 'byemail' : null;
    }
 
    protected function isTimestampValid( $timestamp ) {
        $time = wfTimestampOrNull( TS_MW, $timestamp );
        if ( $time !== null ) {
            $expiry = (int)wfTimestamp( TS_UNIX, $time ) + $this->newPasswordExpiry;
            if ( time() >= $expiry ) {
                return false;
            }
        }
        return true;
    }
 
    protected function sendNewAccountEmail( User $user, User $creatingUser, $password ) {
        $ip = $creatingUser->getRequest()->getIP();
        // @codeCoverageIgnoreStart
        if ( !$ip ) {
            return \Status::newFatal( 'badipaddress' );
        }
        // @codeCoverageIgnoreEnd
 
        $this->getHookRunner()->onUser__mailPasswordInternal( $creatingUser, $ip, $user );
 
        $mainPageUrl = Title::newMainPage()->getCanonicalURL();
        $userLanguage = $this->userOptionsLookup->getOption( $user, 'language' );
        $subjectMessage = wfMessage( 'createaccount-title' )->inLanguage( $userLanguage );
        $bodyMessage = wfMessage( 'createaccount-text', $ip, $user->getName(), $password,
            '<' . $mainPageUrl . '>', round( $this->newPasswordExpiry / 86400 ) )
            ->inLanguage( $userLanguage );
 
        $status = $user->sendMail( $subjectMessage->text(), $bodyMessage->text() );
 
        // TODO show 'mailerror' message on error, 'accmailtext' success message otherwise?
        // @codeCoverageIgnoreStart
        if ( !$status->isGood() ) {
            $this->logger->warning( 'Could not send account creation email: ' .
                $status->getWikiText( false, false, 'en' ) );
        }
        // @codeCoverageIgnoreEnd
 
        return $status;
    }
 
    protected function sendPasswordResetEmail( TemporaryPasswordAuthenticationRequest $req ) {
        $user = User::newFromName( $req->username );
        if ( !$user ) {
            return \Status::newFatal( 'noname' );
        }
        $userLanguage = $this->userOptionsLookup->getOption( $user, 'language' );
        $callerIsAnon = IPUtils::isValid( $req->caller );
        $callerName = $callerIsAnon ? $req->caller : User::newFromName( $req->caller )->getName();
        $passwordMessage = wfMessage( 'passwordreset-emailelement', $user->getName(),
            $req->password )->inLanguage( $userLanguage );
        $emailMessage = wfMessage( $callerIsAnon ? 'passwordreset-emailtext-ip'
            : 'passwordreset-emailtext-user' )->inLanguage( $userLanguage );
        $body = $emailMessage->params( $callerName, $passwordMessage->text(), 1,
            '<' . Title::newMainPage()->getCanonicalURL() . '>',
            round( $this->newPasswordExpiry / 86400 ) )->text();
 
        if ( $this->allowRequiringEmail && !$this->userOptionsLookup
            ->getBoolOption( $user, 'requireemail' )
        ) {
            $body .= "\n\n";
            $url = SpecialPage::getTitleFor( 'Preferences', false, 'mw-prefsection-personal-email' )
                ->getCanonicalURL();
            $body .= wfMessage( 'passwordreset-emailtext-require-email' )
                ->inLanguage( $userLanguage )
                ->params( "<$url>" )
                ->text();
        }
 
        $emailTitle = wfMessage( 'passwordreset-emailtitle' )->inLanguage( $userLanguage );
        return $user->sendMail( $emailTitle->text(), $body );
    }
}