AuthenticationRequest.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Auth;
 
use MediaWiki\Language\RawMessage;
use Message;
use UnexpectedValueException;
 
abstract class AuthenticationRequest {
 
    public const OPTIONAL = 0;
 
    public const REQUIRED = 1;
 
    public const PRIMARY_REQUIRED = 2;
 
    public $action = null;
 
    public $required = self::REQUIRED;
 
    public $returnToUrl = null;
 
    public $username = null;
 
    public function getUniqueId() {
        return get_called_class();
    }
 
    abstract public function getFieldInfo();
 
    public function getMetadata() {
        return [];
    }
 
    public function loadFromSubmission( array $data ) {
        $fields = array_filter( $this->getFieldInfo(), static function ( $info ) {
            return $info['type'] !== 'null';
        } );
        if ( !$fields ) {
            return false;
        }
 
        foreach ( $fields as $field => $info ) {
            // Checkboxes and buttons are special. Depending on the method used
            // to populate $data, they might be unset meaning false or they
            // might be boolean. Further, image buttons might submit the
            // coordinates of the click rather than the expected value.
            if ( $info['type'] === 'checkbox' || $info['type'] === 'button' ) {
                $this->$field = isset( $data[$field] ) && $data[$field] !== false
                    || isset( $data["{$field}_x"] ) && $data["{$field}_x"] !== false;
                if ( !$this->$field && empty( $info['optional'] ) ) {
                    return false;
                }
                continue;
            }
 
            // Multiselect are too, slightly
            if ( !isset( $data[$field] ) && $info['type'] === 'multiselect' ) {
                $data[$field] = [];
            }
 
            if ( !isset( $data[$field] ) ) {
                return false;
            }
            if ( $data[$field] === '' || $data[$field] === [] ) {
                if ( empty( $info['optional'] ) ) {
                    return false;
                }
            } else {
                switch ( $info['type'] ) {
                    case 'select':
                        if ( !isset( $info['options'][$data[$field]] ) ) {
                            return false;
                        }
                        break;
 
                    case 'multiselect':
                        $data[$field] = (array)$data[$field];
                        // @phan-suppress-next-line PhanTypePossiblyInvalidDimOffset required for multiselect
                        $allowed = array_keys( $info['options'] );
                        if ( array_diff( $data[$field], $allowed ) !== [] ) {
                            return false;
                        }
                        break;
                }
            }
 
            $this->$field = $data[$field];
        }
 
        return true;
    }
 
    public function describeCredentials() {
        return [
            'provider' => new RawMessage( '$1', [ get_called_class() ] ),
            'account' => new RawMessage( '$1', [ $this->getUniqueId() ] ),
        ];
    }
 
    public static function loadRequestsFromSubmission( array $reqs, array $data ) {
        $result = [];
        foreach ( $reqs as $req ) {
            if ( $req->loadFromSubmission( $data ) ) {
                $result[] = $req;
            }
        }
        return $result;
    }
 
    public static function getRequestByClass( array $reqs, $class, $allowSubclasses = false ) {
        $requests = array_filter( $reqs, static function ( $req ) use ( $class, $allowSubclasses ) {
            if ( $allowSubclasses ) {
                return is_a( $req, $class, false );
            } else {
                return get_class( $req ) === $class;
            }
        } );
        // @phan-suppress-next-line PhanTypeMismatchReturn False positive
        return count( $requests ) === 1 ? reset( $requests ) : null;
    }
 
    public static function getUsernameFromRequests( array $reqs ) {
        $username = null;
        $otherClass = null;
        foreach ( $reqs as $req ) {
            $info = $req->getFieldInfo();
            if ( $info && array_key_exists( 'username', $info ) && $req->username !== null ) {
                if ( $username === null ) {
                    $username = $req->username;
                    $otherClass = get_class( $req );
                } elseif ( $username !== $req->username ) {
                    $requestClass = get_class( $req );
                    throw new UnexpectedValueException( "Conflicting username fields: \"{$req->username}\" from "
                        // @phan-suppress-next-line PhanTypeSuspiciousStringExpression $otherClass always set
                        . "$requestClass::\$username vs. \"$username\" from $otherClass::\$username" );
                }
            }
        }
        return $username;
    }
 
    public static function mergeFieldInfo( array $reqs ) {
        $merged = [];
 
        // fields that are required by some primary providers but not others are not actually required
        $sharedRequiredPrimaryFields = null;
        foreach ( $reqs as $req ) {
            if ( $req->required !== self::PRIMARY_REQUIRED ) {
                continue;
            }
            $required = [];
            foreach ( $req->getFieldInfo() as $fieldName => $options ) {
                if ( empty( $options['optional'] ) ) {
                    $required[] = $fieldName;
                }
            }
            if ( $sharedRequiredPrimaryFields === null ) {
                $sharedRequiredPrimaryFields = $required;
            } else {
                $sharedRequiredPrimaryFields = array_intersect( $sharedRequiredPrimaryFields, $required );
            }
        }
 
        foreach ( $reqs as $req ) {
            $info = $req->getFieldInfo();
            if ( !$info ) {
                continue;
            }
 
            foreach ( $info as $name => $options ) {
                if (
                    // If the request isn't required, its fields aren't required either.
                    $req->required === self::OPTIONAL
                    // If there is a primary not requiring this field, no matter how many others do,
                    // authentication can proceed without it.
                    || $req->required === self::PRIMARY_REQUIRED
                        // @phan-suppress-next-line PhanTypeMismatchArgumentNullableInternal False positive
                        && !in_array( $name, $sharedRequiredPrimaryFields, true )
                ) {
                    $options['optional'] = true;
                } else {
                    $options['optional'] = !empty( $options['optional'] );
                }
 
                $options['sensitive'] = !empty( $options['sensitive'] );
                $type = $options['type'];
 
                if ( !array_key_exists( $name, $merged ) ) {
                    $merged[$name] = $options;
                } elseif ( $merged[$name]['type'] !== $type ) {
                    throw new UnexpectedValueException( "Field type conflict for \"$name\", " .
                        "\"{$merged[$name]['type']}\" vs \"$type\""
                    );
                } else {
                    if ( isset( $options['options'] ) ) {
                        if ( isset( $merged[$name]['options'] ) ) {
                            $merged[$name]['options'] += $options['options'];
                        } else {
                            // @codeCoverageIgnoreStart
                            $merged[$name]['options'] = $options['options'];
                            // @codeCoverageIgnoreEnd
                        }
                    }
 
                    $merged[$name]['optional'] = $merged[$name]['optional'] && $options['optional'];
                    $merged[$name]['sensitive'] = $merged[$name]['sensitive'] || $options['sensitive'];
 
                    // No way to merge 'value', 'image', 'help', or 'label', so just use
                    // the value from the first request.
                }
            }
        }
 
        return $merged;
    }
 
    public static function __set_state( $data ) {
        // @phan-suppress-next-line PhanTypeInstantiateAbstractStatic
        $ret = new static();
        foreach ( $data as $k => $v ) {
            $ret->$k = $v;
        }
        return $ret;
    }
}