<?php
        
        return [
        
            /*
            |--------------------------------------------------------------------------
            | Authentication Defaults
            |--------------------------------------------------------------------------
            |
            | This option controls the default authentication "guard" and password
            | reset options for your application. You may change these defaults
            | as required, but they're a perfect start for most applications.
            |
            */
        
            'defaults' => [
                'guard' => 'web',
                'passwords' => 'users',
            ],
        
            /*
        |--------------------------------------------------------------------------
        | Authentication Guards
        |--------------------------------------------------------------------------
        |
        | Next, you may define every authentication guard for your application.
        | Of course, a great default configuration has been defined for you
        | here which uses session storage and the Eloquent user provider.
        |
        | All authentication drivers have a user provider. This defines how the
        | users are actually retrieved out of your database or other storage
        | mechanisms used by this application to persist your user's data.
        |
        | Supported: "session", "token"
        |
        */
    
        'guards' => [
            'web' => [
                'driver' => 'session',
                'provider' => 'users',
            ],
    
            'api' => [
                'driver' => 'passport',
                'provider' => 'users',
            ],
        ],
    
        /*
        |--------------------------------------------------------------------------
        | User Providers
        |--------------------------------------------------------------------------
        |
        | All authentication drivers have a user provider. This defines how the
        | users are actually retrieved out of your database or other storage
        | mechanisms used by this application to persist your user's data.
        |
        | If you have multiple user tables or models you may configure multiple
        | sources which represent each model / table. These sources may then
        | be assigned to any extra authentication guards you have defined.
        |
        | Supported: "database", "eloquent"
        |
        */
    
        'providers' => [
            'users' => [
                'driver' => 'eloquent',
                'model' => App\User::class,
            ],
    
            // 'users' => [
            //     'driver' => 'database',
            //     'table' => 'users',
            // ],
        ],
    
        /*
        |--------------------------------------------------------------------------
        | Resetting Passwords
        |--------------------------------------------------------------------------
        |
        | You may specify multiple password reset configurations if you have more
        | than one user table or model in the application and you want to have
        | separate password reset settings based on the specific user types.
        |
        | The expire time is the number of minutes that the reset token should be
        | considered valid. This security feature keeps tokens short-lived so
        | they have less time to be guessed. You may change this as needed.
        |
        */
    
        'passwords' => [
            'users' => [
                'provider' => 'users',
                'table' => 'password_resets',
                'expire' => 60,
            ],
        ],
    
    ];

          'guards' => [
                'web' => [
                    'driver' => 'session',
                    'provider' => 'users',
                ],
            ],

    'providers' => [
            'admins' => [
                'driver' => 'eloquent',
                'model' => App\Admin::class
            ]
        ],

    //Illuminate\Auth\SessionGuard
     public function attempt(array $credentials = [], $remember = false)
        {
            $this->fireAttemptEvent($credentials, $remember);
    
            $this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);
    
            // If an implementation of UserInterface was returned, we'll ask the provider
            // to validate the user against the given credentials, and if they are in
            // fact valid we'll log the users into the application and return true.
            if ($this->hasValidCredentials($user, $credentials)) {
                $this->login($user, $remember);
    
                return true;
            }
    
            // If the authentication attempt fails we will fire an event so that the user
            // may be notified of any suspicious attempts to access their account from
            // an unrecognized user. A developer may listen to this event as needed.
            $this->fireFailedEvent($user, $credentials);
    
            return false;
        }

    //Illuminate\Auth\EloquentUserProvider
    public function retrieveByCredentials(array $credentials)
        {
            if (empty($credentials) ||
               (count($credentials) === 1 &&
                array_key_exists('password', $credentials))) {
                return;
            }
    
            // First we will add each credential element to the query as a where clause.
            // Then we can execute the query and, if we found a user, return it in a
            // Eloquent User "model" that will be utilized by the Guard instances.
            $query = $this->createModel()->newQuery();
    
            foreach ($credentials as $key => $value) {
                if (Str::contains($key, 'password')) {
                    continue;
                }
    
                if (is_array($value) || $value instanceof Arrayable) {
                    $query->whereIn($key, $value);
                } else {
                    $query->where($key, $value);
                }
            }
    
            return $query->first();
        }

    //Illuminate\Auth\SessionGuard
    /**
         * Determine if the user matches the credentials.
         *
         * @param  mixed  $user
         * @param  array  $credentials
         * @return bool
         */
        protected function hasValidCredentials($user, $credentials)
        {
            return ! is_null($user) && $this->provider->validateCredentials($user, $credentials);
        }

    //Illuminate\Auth\EloquentUserProvider
    public function validateCredentials(UserContract $user, array $credentials)
    {
        $plain = $credentials['password'];
    
        return $this->hasher->check($plain, $user->getAuthPassword());
    }

    // App\Admin
    public function getAuthPassword()
    {
        return $this->login_pass;
    }

    public function getAuthPassword()
        {
            return ['password' => $this->attributes['password'], 'salt' => $this->attributes['salt']];
        }

    <?php 
    namespace App\Foundation\Auth;
    
    use Illuminate\Auth\EloquentUserProvider;
    use Illuminate\Contracts\Auth\Authenticatable;
    use Illuminate\Support\Str;
    
    /**
     * 重寫用戶密碼校驗邏輯
     * Class GfzxEloquentUserProvider
     * @package App\Foundation\Auth
     */
    class GfzxEloquentUserProvider extends EloquentUserProvider
    {
        /**
         * Validate a user against the given credentials.
         *
         * @param  \Illuminate\Contracts\Auth\Authenticatable $user
         * @param  array $credentials
         * @return bool
         */
        public function validateCredentials(Authenticatable $user, array $credentials)
        {
            $plain = $credentials['password'];
            $authPassword = $user->getAuthPassword();
            return md5($plain . $authPassword['salt']) == $authPassword['password'];
        }
    }

    <?php
    
    namespace App\Providers;
    
    use App\Foundation\Auth\GfzxEloquentUserProvider;
    use Auth;
    use Illuminate\Support\Facades\Gate;
    use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
    
    class AuthServiceProvider extends ServiceProvider
    {
        .
        .
        .
    
        /**
         * Register any authentication / authorization services.
         *
         * @return void
         */
        public function boot()
        {
            $this->registerPolicies();
    
            Auth::provider('gfzx-eloquent', function ($app, $config) {
                return new GfzxEloquentUserProvider($this->app['hash'], $config['model']);
            });
        }
    }

       'providers' => [
            'users' => [
                'driver' => 'gfzx-eloquent',
                'model' => App\Models\User::class,
            ],
        ],