PasswordFactory.php

Go to the documentation of this file.

<?php
final class PasswordFactory {
    private $default = '';
 
    private $types = [
        '' => [ 'type' => '', 'class' => InvalidPassword::class ],
    ];
 
    public function __construct( array $config = [], $default = '' ) {
        foreach ( $config as $type => $options ) {
            $this->register( $type, $options );
        }
 
        if ( $default !== '' ) {
            $this->setDefaultType( $default );
        }
    }
 
    public function register( $type, array $config ) {
        $config['type'] = $type;
        $this->types[$type] = $config;
    }
 
    public function setDefaultType( $type ) {
        if ( !isset( $this->types[$type] ) ) {
            throw new InvalidArgumentException( "Invalid password type $type." );
        }
        $this->default = $type;
    }
 
    public function getDefaultType() {
        return $this->default;
    }
 
    public function init( Config $config ) {
        foreach ( $config->get( 'PasswordConfig' ) as $type => $options ) {
            $this->register( $type, $options );
        }
 
        $this->setDefaultType( $config->get( 'PasswordDefault' ) );
    }
 
    public function getTypes() {
        return $this->types;
    }
 
    public function newFromCiphertext( $hash ) {
        if ( $hash === null || $hash === false || $hash === '' ) {
            return new InvalidPassword( $this, [ 'type' => '' ], null );
        } elseif ( $hash[0] !== ':' ) {
            throw new PasswordError( 'Invalid hash given' );
        }
 
        $type = substr( $hash, 1, strpos( $hash, ':', 1 ) - 1 );
        if ( !isset( $this->types[$type] ) ) {
            throw new PasswordError( "Unrecognized password hash type $type." );
        }
 
        $config = $this->types[$type];
 
        return new $config['class']( $this, $config, $hash );
    }
 
    public function newFromType( $type ) {
        if ( !isset( $this->types[$type] ) ) {
            throw new PasswordError( "Unrecognized password hash type $type." );
        }
 
        $config = $this->types[$type];
 
        return new $config['class']( $this, $config );
    }
 
    public function newFromPlaintext( $password, Password $existing = null ) {
        if ( $password === null ) {
            return new InvalidPassword( $this, [ 'type' => '' ], null );
        }
 
        if ( $existing === null ) {
            $config = $this->types[$this->default];
            $obj = new $config['class']( $this, $config );
        } else {
            $obj = clone $existing;
        }
 
        $obj->crypt( $password );
 
        return $obj;
    }
 
    public function needsUpdate( Password $password ) {
        if ( $password->getType() !== $this->default ) {
            return true;
        } else {
            return $password->needsUpdate();
        }
    }
 
    public static function generateRandomPasswordString( $minLength = 10 ) {
        // Decide the final password length based on our min password length,
        // stopping at a minimum of 10 chars.
        $length = max( 10, $minLength );
        // Multiply by 1.25 to get the number of hex characters we need
        // Generate random hex chars
        $hex = MWCryptRand::generateHex( ceil( $length * 1.25 ) );
        // Convert from base 16 to base 32 to get a proper password like string
        return substr( Wikimedia\base_convert( $hex, 16, 32, $length ), -$length );
    }
 
    public static function newInvalidPassword() {
        static $password = null;
 
        if ( $password === null ) {
            $factory = new self();
            $password = new InvalidPassword( $factory, [ 'type' => '' ], null );
        }
 
        return $password;
    }
}