1917 lines
52 KiB
Markdown
1917 lines
52 KiB
Markdown
---
|
||
title: 用户认证
|
||
---
|
||
|
||
## 安装
|
||
|
||
下表列出了`Laravel Auth`系统的核心部件
|
||
|
||
| 名称 | 作用 |
|
||
| ------------- | ------------------------------------------------------------ |
|
||
| Auth | AuthManager的Facade |
|
||
| AuthManager | Auth认证系统面向外部的接口，认证系统通过它向应用提供所有与用户认证相关的功能|
|
||
| Guard | 看守器，定义了该如何认证每个请求中用户 |
|
||
| User Provider | 用户提供器，定义了如何从持久化的存储数据中检索用户 |
|
||
|
||
`Laravel Auth`已不再默认跟随框架安装，需要手动安装。
|
||
{%copy composer require laravel/ui %}
|
||
安装完成后，在命令行发布资源文件。
|
||
{%copy php artisan ui bootstrap --auth %}
|
||
你可以在`App\Http\Controllers`命名空间下，找到`Auth`目录。在`resources/views/auth`目录下，找到对应的资源文件。
|
||
|
||
## 配置文件
|
||
`Laravel Auth`使用的配置文件在`config\auth.php`中。
|
||
```php
|
||
// config\auth.php
|
||
return [
|
||
|
||
/*
|
||
|--------------------------------------------------------------------------
|
||
| 默认看守器
|
||
|--------------------------------------------------------------------------
|
||
|
|
||
| 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"
|
||
|
|
||
*/
|
||
|
||
'guards' => [
|
||
'web' => [
|
||
'driver' => 'session',
|
||
'provider' => 'users',
|
||
],
|
||
],
|
||
|
||
/*
|
||
|--------------------------------------------------------------------------
|
||
| User Providers
|
||
|--------------------------------------------------------------------------
|
||
|
|
||
| 所有的驱动都有一个用户提供者，它定义了如何从数据库或者应用使用的持久化用户数据的存储中取出用户信息
|
||
| Supported: "database", "eloquent"
|
||
|
|
||
*/
|
||
|
||
'providers' => [
|
||
'users' => [
|
||
'driver' => 'eloquent',
|
||
'model' => App\Models\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 each reset token will 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,
|
||
'throttle' => 60,
|
||
],
|
||
],
|
||
|
||
/*
|
||
|--------------------------------------------------------------------------
|
||
| Password Confirmation Timeout
|
||
|--------------------------------------------------------------------------
|
||
|
|
||
| Here you may define the amount of seconds before a password confirmation
|
||
| times out and the user is prompted to re-enter their password via the
|
||
| confirmation screen. By default, the timeout lasts for three hours.
|
||
|
|
||
*/
|
||
|
||
'password_timeout' => 10800,
|
||
|
||
];
|
||
```
|
||
|
||
`Auth`系统默认使用`session`和`cookies`维护状态，使用的看守器是`sessionGuard`，用户提供器是`EloquentUserProvider`，提供器是`App\Model\Users`。
|
||
|
||
## 看守器
|
||
在`Laravel`中，"看守器"（`Guard`）是一种身份验证系统的抽象概念。它允许你定义不同的身份验证来源，并为每个来源指定不同的用户身份验证逻辑。 Laravel内置了一些常见的看守器，比如`Session Guard`和`Token Guard`，但你也可以自定义自己的看守器以适应特定的身份验证需求。
|
||
|
||
每个看守器都有一个相应的提供者（`Provider`），提供者定义了如何从不同的数据源中检索用户信息。例如，`Eloquent`提供者用于从数据库中检索用户信息，而`Token`提供者用于从`API`令牌中检索用户信息。
|
||
|
||
查看`SessionGuard`类，是`StatefulGuard`、`Guard`、`SupportsBasicAuth`的具体实现，查看各类，
|
||
|
||
### Guard
|
||
```php
|
||
namespace Illuminate\Contracts\Auth;
|
||
|
||
interface Guard
|
||
{
|
||
/**
|
||
* 检查用户是否已登录
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function check();
|
||
|
||
/**
|
||
* 验证是否未登录
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function guest();
|
||
|
||
/**
|
||
* 获取当前用户信息
|
||
*
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function user();
|
||
|
||
/**
|
||
* 获取当前用户ID
|
||
*
|
||
* @return int|string|null
|
||
*/
|
||
public function id();
|
||
|
||
/**
|
||
* 通过该方法验证用户
|
||
*
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
public function validate(array $credentials = []);
|
||
|
||
/**
|
||
* 设置当前认证通过的用户
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
public function setUser(Authenticatable $user);
|
||
}
|
||
|
||
```
|
||
|
||
### StatefulGuard
|
||
|
||
```php
|
||
namespace Illuminate\Contracts\Auth;
|
||
|
||
interface StatefulGuard extends Guard
|
||
{
|
||
/**
|
||
* 通过给定数据验证用户，如果$remember为true，则会设置一个cookie，用于记住用户
|
||
*
|
||
* @param array $credentials
|
||
* @param bool $remember
|
||
* @return bool
|
||
*/
|
||
public function attempt(array $credentials = [], $remember = false);
|
||
|
||
/**
|
||
* 认证用户，认证成功后不会设置session和cookies数据
|
||
*
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
public function once(array $credentials = []);
|
||
|
||
/**
|
||
* 登录用户（登录成功后设置相应session和cookies数据）
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @param bool $remember
|
||
* @return void
|
||
*/
|
||
public function login(Authenticatable $user, $remember = false);
|
||
|
||
/**
|
||
* 通过给定的用户id登录用户
|
||
*
|
||
* @param mixed $id
|
||
* @param bool $remember
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|bool
|
||
*/
|
||
public function loginUsingId($id, $remember = false);
|
||
|
||
/**
|
||
*通过给定的id登录系统，不设置session和cookies数据
|
||
*
|
||
* @param mixed $id
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|bool
|
||
*/
|
||
public function onceUsingId($id);
|
||
|
||
/**
|
||
* Determine if the user was authenticated via "remember me" cookie.
|
||
* 判断用户是否通过name为remeber me的cookie值认证的
|
||
* @return bool
|
||
*/
|
||
public function viaRemember();
|
||
|
||
/**
|
||
* 退出登录
|
||
*
|
||
* @return void
|
||
*/
|
||
public function logout();
|
||
}
|
||
|
||
```
|
||
|
||
### SupportsBasicAuth
|
||
|
||
```php
|
||
|
||
namespace Illuminate\Contracts\Auth;
|
||
|
||
interface SupportsBasicAuth
|
||
{
|
||
/**
|
||
* 尝试使用http basic auth来认证用户
|
||
*
|
||
* @param string $field
|
||
* @param array $extraConditions
|
||
* @return \Symfony\Component\HttpFoundation\Response|null
|
||
*/
|
||
public function basic($field = 'email', $extraConditions = []);
|
||
|
||
/**
|
||
* 仅需无状态的http basic auth认证，（不设置session和cookies）
|
||
*
|
||
* @param string $field
|
||
* @param array $extraConditions
|
||
* @return \Symfony\Component\HttpFoundation\Response|null
|
||
*/
|
||
public function onceBasic($field = 'email', $extraConditions = []);
|
||
}
|
||
|
||
```
|
||
|
||
## 用户提供器
|
||
定义如何从持久化的存储数据中检索用户， `Laravel`提供了用户提供器契约，所有用户提供器都要实现这个接口。
|
||
|
||
### UserPrivoder
|
||
```php
|
||
<?php
|
||
|
||
namespace Illuminate\Contracts\Auth;
|
||
|
||
interface UserProvider
|
||
{
|
||
/**
|
||
* 通过用户id获取用户数据
|
||
*
|
||
* @param mixed $identifier
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function retrieveById($identifier);
|
||
|
||
/**
|
||
* 通过cookies中的remeber me token获取用户数据
|
||
*
|
||
* @param mixed $identifier
|
||
* @param string $token
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function retrieveByToken($identifier, $token);
|
||
|
||
/**
|
||
* 更新数据存储中给定的用户的remeber me token令牌
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @param string $token
|
||
* @return void
|
||
*/
|
||
public function updateRememberToken(Authenticatable $user, $token);
|
||
|
||
/**
|
||
* 通过证书获取用户信息
|
||
*
|
||
* @param array $credentials
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function retrieveByCredentials(array $credentials);
|
||
|
||
/**
|
||
* 验证用户证书
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
public function validateCredentials(Authenticatable $user, array $credentials);
|
||
}
|
||
|
||
```
|
||
|
||
`Laravel`默认提供了一个`EloquentUserProvider`用户提供器，它使用`Eloquent`模型来存储用户数据。
|
||
|
||
### EloquentUserProvider
|
||
```php
|
||
|
||
namespace Illuminate\Auth;
|
||
|
||
use Closure;
|
||
use Illuminate\Contracts\Auth\Authenticatable as UserContract;
|
||
use Illuminate\Contracts\Auth\UserProvider;
|
||
use Illuminate\Contracts\Hashing\Hasher as HasherContract;
|
||
use Illuminate\Contracts\Support\Arrayable;
|
||
use Illuminate\Support\Str;
|
||
|
||
class EloquentUserProvider implements UserProvider
|
||
{
|
||
/**
|
||
* The hasher implementation.
|
||
*
|
||
* @var \Illuminate\Contracts\Hashing\Hasher
|
||
*/
|
||
protected $hasher;
|
||
|
||
/**
|
||
* The Eloquent user model.
|
||
*
|
||
* @var string
|
||
*/
|
||
protected $model;
|
||
|
||
/**
|
||
* 构造方法传入配置的model 和哈希处理类Hasher
|
||
*
|
||
* @param \Illuminate\Contracts\Hashing\Hasher $hasher
|
||
* @param string $model
|
||
* @return void
|
||
*/
|
||
public function __construct(HasherContract $hasher, $model)
|
||
{
|
||
$this->model = $model;
|
||
$this->hasher = $hasher;
|
||
}
|
||
|
||
/**
|
||
* Retrieve a user by their unique identifier.
|
||
*
|
||
* @param mixed $identifier
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function retrieveById($identifier)
|
||
{
|
||
$model = $this->createModel();
|
||
|
||
return $this->newModelQuery($model)
|
||
->where($model->getAuthIdentifierName(), $identifier)
|
||
->first();
|
||
}
|
||
|
||
/**
|
||
* Retrieve a user by their unique identifier and "remember me" token.
|
||
*
|
||
* @param mixed $identifier
|
||
* @param string $token
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function retrieveByToken($identifier, $token)
|
||
{
|
||
$model = $this->createModel();
|
||
|
||
$retrievedModel = $this->newModelQuery($model)->where(
|
||
$model->getAuthIdentifierName(), $identifier
|
||
)->first();
|
||
|
||
if (! $retrievedModel) {
|
||
return;
|
||
}
|
||
|
||
$rememberToken = $retrievedModel->getRememberToken();
|
||
|
||
return $rememberToken && hash_equals($rememberToken, $token)
|
||
? $retrievedModel : null;
|
||
}
|
||
|
||
/**
|
||
* Update the "remember me" token for the given user in storage.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable|\Illuminate\Database\Eloquent\Model $user
|
||
* @param string $token
|
||
* @return void
|
||
*/
|
||
public function updateRememberToken(UserContract $user, $token)
|
||
{
|
||
$user->setRememberToken($token);
|
||
|
||
$timestamps = $user->timestamps;
|
||
|
||
$user->timestamps = false;
|
||
|
||
$user->save();
|
||
|
||
$user->timestamps = $timestamps;
|
||
}
|
||
|
||
/**
|
||
* 该方法是laravel默认进行认证的方法
|
||
*
|
||
* @param array $credentials
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function retrieveByCredentials(array $credentials)
|
||
{
|
||
if (empty($credentials) ||
|
||
(count($credentials) === 1 &&
|
||
Str::contains($this->firstCredentialKey($credentials), 'password'))) {
|
||
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->newModelQuery();
|
||
|
||
foreach ($credentials as $key => $value) {
|
||
if (Str::contains($key, 'password')) {
|
||
continue;
|
||
}
|
||
|
||
if (is_array($value) || $value instanceof Arrayable) {
|
||
$query->whereIn($key, $value);
|
||
} elseif ($value instanceof Closure) {
|
||
$value($query);
|
||
} else {
|
||
$query->where($key, $value);
|
||
}
|
||
}
|
||
|
||
return $query->first();
|
||
}
|
||
|
||
/**
|
||
* Get the first key from the credential array.
|
||
*
|
||
* @param array $credentials
|
||
* @return string|null
|
||
*/
|
||
protected function firstCredentialKey(array $credentials)
|
||
{
|
||
foreach ($credentials as $key => $value) {
|
||
return $key;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 默认密码验证，使用hasher进行密码验证
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
public function validateCredentials(UserContract $user, array $credentials)
|
||
{
|
||
$plain = $credentials['password'];
|
||
|
||
return $this->hasher->check($plain, $user->getAuthPassword());
|
||
}
|
||
|
||
/**
|
||
* Get a new query builder for the model instance.
|
||
*
|
||
* @param \Illuminate\Database\Eloquent\Model|null $model
|
||
* @return \Illuminate\Database\Eloquent\Builder
|
||
*/
|
||
protected function newModelQuery($model = null)
|
||
{
|
||
return is_null($model)
|
||
? $this->createModel()->newQuery()
|
||
: $model->newQuery();
|
||
}
|
||
|
||
/**
|
||
* Create a new instance of the model.
|
||
*
|
||
* @return \Illuminate\Database\Eloquent\Model
|
||
*/
|
||
public function createModel()
|
||
{
|
||
$class = '\\'.ltrim($this->model, '\\');
|
||
|
||
return new $class;
|
||
}
|
||
|
||
/**
|
||
* Gets the hasher implementation.
|
||
*
|
||
* @return \Illuminate\Contracts\Hashing\Hasher
|
||
*/
|
||
public function getHasher()
|
||
{
|
||
return $this->hasher;
|
||
}
|
||
|
||
/**
|
||
* Sets the hasher implementation.
|
||
*
|
||
* @param \Illuminate\Contracts\Hashing\Hasher $hasher
|
||
* @return $this
|
||
*/
|
||
public function setHasher(HasherContract $hasher)
|
||
{
|
||
$this->hasher = $hasher;
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* Gets the name of the Eloquent user model.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function getModel()
|
||
{
|
||
return $this->model;
|
||
}
|
||
|
||
/**
|
||
* Sets the name of the Eloquent user model.
|
||
*
|
||
* @param string $model
|
||
* @return $this
|
||
*/
|
||
public function setModel($model)
|
||
{
|
||
$this->model = $model;
|
||
|
||
return $this;
|
||
}
|
||
}
|
||
|
||
|
||
```
|
||
|
||
以上用户看守器和用户提供器都已经分析完毕，接下来看看用户认证的流程。
|
||
|
||
## 登录认证
|
||
当用户输入认证信息点击登录后，查找`LoginController`中的登录方法，
|
||
```php
|
||
|
||
namespace App\Http\Controllers\Auth;
|
||
|
||
use App\Http\Controllers\Controller;
|
||
use App\Providers\RouteServiceProvider;
|
||
use Illuminate\Foundation\Auth\AuthenticatesUsers;
|
||
|
||
class LoginController extends Controller
|
||
{
|
||
/*
|
||
|--------------------------------------------------------------------------
|
||
| Login Controller
|
||
|--------------------------------------------------------------------------
|
||
|
|
||
| This controller handles authenticating users for the application and
|
||
| redirecting them to your home screen. The controller uses a trait
|
||
| to conveniently provide its functionality to your applications.
|
||
|
|
||
*/
|
||
|
||
use AuthenticatesUsers;
|
||
|
||
/**
|
||
* Where to redirect users after login.
|
||
*
|
||
* @var string
|
||
*/
|
||
protected $redirectTo = RouteServiceProvider::HOME;
|
||
|
||
/**
|
||
* Create a new controller instance.
|
||
*
|
||
* @return void
|
||
*/
|
||
public function __construct()
|
||
{
|
||
// 使用guest中间件
|
||
$this->middleware('guest')->except('logout');
|
||
}
|
||
}
|
||
```
|
||
在该控制器中未找到登录方法，查看`AuthenticatesUsers` `trait`,
|
||
```php
|
||
namespace Illuminate\Foundation\Auth;
|
||
|
||
use Illuminate\Http\JsonResponse;
|
||
use Illuminate\Http\Request;
|
||
use Illuminate\Support\Facades\Auth;
|
||
use Illuminate\Validation\ValidationException;
|
||
|
||
trait AuthenticatesUsers
|
||
{
|
||
use RedirectsUsers, ThrottlesLogins;
|
||
|
||
/**
|
||
* Show the application's login form.
|
||
*
|
||
* @return \Illuminate\View\View
|
||
*/
|
||
public function showLoginForm()
|
||
{
|
||
return view('auth.login');
|
||
}
|
||
|
||
/**
|
||
* 登录认证方法
|
||
*
|
||
* @param \Illuminate\Http\Request $request
|
||
* @return \Illuminate\Http\RedirectResponse|\Illuminate\Http\Response|\Illuminate\Http\JsonResponse
|
||
*
|
||
* @throws \Illuminate\Validation\ValidationException
|
||
*/
|
||
public function login(Request $request)
|
||
{
|
||
// 验证提交的信息
|
||
$this->validateLogin($request);
|
||
|
||
// If the class is using the ThrottlesLogins trait, we can automatically throttle
|
||
// the login attempts for this application. We'll key this by the username and
|
||
// the IP address of the client making these requests into this application.
|
||
// 通过注释可知，使用ThrottlesLogins trait，可以自动限制登录次数
|
||
if (method_exists($this, 'hasTooManyLoginAttempts') &&
|
||
$this->hasTooManyLoginAttempts($request)) {
|
||
// 触发事件
|
||
$this->fireLockoutEvent($request);
|
||
|
||
return $this->sendLockoutResponse($request);
|
||
}
|
||
// 重点重点重点 attemptLogin 进行登录验证
|
||
if ($this->attemptLogin($request)) {
|
||
if ($request->hasSession()) {
|
||
$request->session()->put('auth.password_confirmed_at', time());
|
||
}
|
||
|
||
return $this->sendLoginResponse($request);
|
||
}
|
||
|
||
// If the login attempt was unsuccessful we will increment the number of attempts
|
||
// to login and redirect the user back to the login form. Of course, when this
|
||
// user surpasses their maximum number of attempts they will get locked out.
|
||
$this->incrementLoginAttempts($request);
|
||
|
||
return $this->sendFailedLoginResponse($request);
|
||
}
|
||
|
||
/**
|
||
* Validate the user login request.
|
||
*
|
||
* @param \Illuminate\Http\Request $request
|
||
* @return void
|
||
*
|
||
* @throws \Illuminate\Validation\ValidationException
|
||
*/
|
||
protected function validateLogin(Request $request)
|
||
{
|
||
$request->validate([
|
||
$this->username() => 'required|string',
|
||
'password' => 'required|string',
|
||
]);
|
||
}
|
||
|
||
/**
|
||
* 验证用户登录是否成功
|
||
*
|
||
* @param \Illuminate\Http\Request $request
|
||
* @return bool
|
||
*/
|
||
protected function attemptLogin(Request $request)
|
||
{
|
||
/**
|
||
* 首先查看$this->guard()，返回的是Auth::guard()，Auth是laravel的facade类，其具体是AuthManager类
|
||
*
|
||
* */
|
||
return $this->guard()->attempt(
|
||
$this->credentials($request), $request->boolean('remember')
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Get the needed authorization credentials from the request.
|
||
*
|
||
* @param \Illuminate\Http\Request $request
|
||
* @return array
|
||
*/
|
||
protected function credentials(Request $request)
|
||
{
|
||
return $request->only($this->username(), 'password');
|
||
}
|
||
|
||
/**
|
||
* Get the guard to be used during authentication.
|
||
*
|
||
* @return \Illuminate\Contracts\Auth\StatefulGuard
|
||
*/
|
||
protected function guard()
|
||
{
|
||
// Authmanager类
|
||
return Auth::guard();
|
||
}
|
||
//...
|
||
}
|
||
```
|
||
|
||
### AuthManager
|
||
```php
|
||
namespace Illuminate\Auth;
|
||
|
||
use Closure;
|
||
use Illuminate\Contracts\Auth\Factory as FactoryContract;
|
||
use InvalidArgumentException;
|
||
|
||
class AuthManager implements FactoryContract
|
||
{
|
||
use CreatesUserProviders;
|
||
// ...
|
||
/**
|
||
* 获取指定的认证驱动
|
||
*
|
||
* @param string|null $name
|
||
* @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard
|
||
*/
|
||
public function guard($name = null)
|
||
{
|
||
// 获取看守器名
|
||
$name = $name ?: $this->getDefaultDriver();
|
||
// 首次guards不存在，则调用resolve解析看守器
|
||
return $this->guards[$name] ?? $this->guards[$name] = $this->resolve($name);
|
||
}
|
||
```
|
||
#### resolve方法
|
||
```php
|
||
/**
|
||
* 解析看守器
|
||
*
|
||
* @param string $name
|
||
* @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard
|
||
*
|
||
* @throws \InvalidArgumentException
|
||
*/
|
||
protected function resolve($name)
|
||
{
|
||
// 从配置文件中获取驱动配置
|
||
$config = $this->getConfig($name);
|
||
|
||
if (is_null($config)) {
|
||
throw new InvalidArgumentException("Auth guard [{$name}] is not defined.");
|
||
}
|
||
// 如果通过extend方法自定义了驱动器，这里则调用自定义的guard驱动器
|
||
if (isset($this->customCreators[$config['driver']])) {
|
||
return $this->callCustomCreator($name, $config);
|
||
}
|
||
// laravel默认执行createSessionDriver方法
|
||
$driverMethod = 'create'.ucfirst($config['driver']).'Driver';
|
||
|
||
//createSessionDriver方法调用
|
||
if (method_exists($this, $driverMethod)) {
|
||
return $this->{$driverMethod}($name, $config);
|
||
}
|
||
|
||
throw new InvalidArgumentException(
|
||
"Auth driver [{$config['driver']}] for guard [{$name}] is not defined."
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Call a custom driver creator.
|
||
*
|
||
* @param string $name
|
||
* @param array $config
|
||
* @return mixed
|
||
*/
|
||
protected function callCustomCreator($name, array $config)
|
||
{
|
||
return $this->customCreators[$config['driver']]($this->app, $name, $config);
|
||
}
|
||
```
|
||
##### createSessionDriver方法
|
||
```php
|
||
/**
|
||
* 创建基于session的看守器
|
||
*
|
||
* @param string $name
|
||
* @param array $config
|
||
* @return \Illuminate\Auth\SessionGuard
|
||
*/
|
||
public function createSessionDriver($name, $config)
|
||
{
|
||
// 获取用户提供器
|
||
$provider = $this->createUserProvider($config['provider'] ?? null);
|
||
// 默认的看守器实例
|
||
$guard = new SessionGuard(
|
||
$name,
|
||
$provider,
|
||
$this->app['session.store'],
|
||
);
|
||
|
||
// When using the remember me functionality of the authentication services we
|
||
// will need to be set the encryption instance of the guard, which allows
|
||
// secure, encrypted cookie values to get generated for those cookies.
|
||
if (method_exists($guard, 'setCookieJar')) {
|
||
$guard->setCookieJar($this->app['cookie']);
|
||
}
|
||
|
||
if (method_exists($guard, 'setDispatcher')) {
|
||
$guard->setDispatcher($this->app['events']);
|
||
}
|
||
|
||
if (method_exists($guard, 'setRequest')) {
|
||
$guard->setRequest($this->app->refresh('request', $guard, 'setRequest'));
|
||
}
|
||
|
||
if (isset($config['remember'])) {
|
||
$guard->setRememberDuration($config['remember']);
|
||
}
|
||
|
||
return $guard;
|
||
}
|
||
|
||
/**
|
||
* Get the guard configuration.
|
||
*
|
||
* @param string $name
|
||
* @return array
|
||
*/
|
||
protected function getConfig($name)
|
||
{
|
||
return $this->app['config']["auth.guards.{$name}"];
|
||
}
|
||
|
||
/**
|
||
* Get the default authentication driver name.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function getDefaultDriver()
|
||
{
|
||
return $this->app['config']['auth.defaults.guard'];
|
||
}
|
||
|
||
/**
|
||
* Register a custom driver creator Closure.
|
||
*
|
||
* @param string $driver
|
||
* @param \Closure $callback
|
||
* @return $this
|
||
*/
|
||
public function extend($driver, Closure $callback)
|
||
{
|
||
$this->customCreators[$driver] = $callback;
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* Register a custom provider creator Closure.
|
||
*
|
||
* @param string $name
|
||
* @param \Closure $callback
|
||
* @return $this
|
||
*/
|
||
public function provider($name, Closure $callback)
|
||
{
|
||
$this->customProviderCreators[$name] = $callback;
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* Dynamically call the default driver instance.
|
||
*
|
||
* @param string $method
|
||
* @param array $parameters
|
||
* @return mixed
|
||
*/
|
||
public function __call($method, $parameters)
|
||
{
|
||
return $this->guard()->{$method}(...$parameters);
|
||
}
|
||
|
||
//...
|
||
}
|
||
|
||
```
|
||
###### SessionGuard类
|
||
```php
|
||
|
||
namespace Illuminate\Auth;
|
||
|
||
use Illuminate\Auth\Events\Attempting;
|
||
use Illuminate\Auth\Events\Authenticated;
|
||
use Illuminate\Auth\Events\CurrentDeviceLogout;
|
||
use Illuminate\Auth\Events\Failed;
|
||
use Illuminate\Auth\Events\Login;
|
||
use Illuminate\Auth\Events\Logout;
|
||
use Illuminate\Auth\Events\OtherDeviceLogout;
|
||
use Illuminate\Auth\Events\Validated;
|
||
use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
|
||
use Illuminate\Contracts\Auth\StatefulGuard;
|
||
use Illuminate\Contracts\Auth\SupportsBasicAuth;
|
||
use Illuminate\Contracts\Auth\UserProvider;
|
||
use Illuminate\Contracts\Cookie\QueueingFactory as CookieJar;
|
||
use Illuminate\Contracts\Events\Dispatcher;
|
||
use Illuminate\Contracts\Session\Session;
|
||
use Illuminate\Support\Arr;
|
||
use Illuminate\Support\Facades\Hash;
|
||
use Illuminate\Support\Str;
|
||
use Illuminate\Support\Timebox;
|
||
use Illuminate\Support\Traits\Macroable;
|
||
use InvalidArgumentException;
|
||
use RuntimeException;
|
||
use Symfony\Component\HttpFoundation\Request;
|
||
use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
|
||
|
||
class SessionGuard implements StatefulGuard, SupportsBasicAuth
|
||
{
|
||
use GuardHelpers, Macroable;
|
||
|
||
/**
|
||
* The name of the guard. Typically "web".
|
||
*
|
||
* Corresponds to guard name in authentication configuration.
|
||
*
|
||
* @var string
|
||
*/
|
||
protected $name;
|
||
|
||
/**
|
||
* The user we last attempted to retrieve.
|
||
*
|
||
* @var \Illuminate\Contracts\Auth\Authenticatable
|
||
*/
|
||
protected $lastAttempted;
|
||
|
||
/**
|
||
* Indicates if the user was authenticated via a recaller cookie.
|
||
*
|
||
* @var bool
|
||
*/
|
||
protected $viaRemember = false;
|
||
|
||
/**
|
||
* The number of minutes that the "remember me" cookie should be valid for.
|
||
*
|
||
* @var int
|
||
*/
|
||
protected $rememberDuration = 2628000;
|
||
|
||
/**
|
||
* The session used by the guard.
|
||
*
|
||
* @var \Illuminate\Contracts\Session\Session
|
||
*/
|
||
protected $session;
|
||
|
||
/**
|
||
* The Illuminate cookie creator service.
|
||
*
|
||
* @var \Illuminate\Contracts\Cookie\QueueingFactory
|
||
*/
|
||
protected $cookie;
|
||
|
||
/**
|
||
* The request instance.
|
||
*
|
||
* @var \Symfony\Component\HttpFoundation\Request
|
||
*/
|
||
protected $request;
|
||
|
||
/**
|
||
* The event dispatcher instance.
|
||
*
|
||
* @var \Illuminate\Contracts\Events\Dispatcher
|
||
*/
|
||
protected $events;
|
||
|
||
/**
|
||
* The timebox instance.
|
||
*
|
||
* @var \Illuminate\Support\Timebox
|
||
*/
|
||
protected $timebox;
|
||
|
||
/**
|
||
* Indicates if the logout method has been called.
|
||
*
|
||
* @var bool
|
||
*/
|
||
protected $loggedOut = false;
|
||
|
||
/**
|
||
* Indicates if a token user retrieval has been attempted.
|
||
*
|
||
* @var bool
|
||
*/
|
||
protected $recallAttempted = false;
|
||
|
||
/**
|
||
* Create a new authentication guard.
|
||
*
|
||
* @param string $name
|
||
* @param \Illuminate\Contracts\Auth\UserProvider $provider
|
||
* @param \Illuminate\Contracts\Session\Session $session
|
||
* @param \Symfony\Component\HttpFoundation\Request|null $request
|
||
* @param \Illuminate\Support\Timebox|null $timebox
|
||
* @return void
|
||
*/
|
||
public function __construct($name,
|
||
UserProvider $provider,
|
||
Session $session,
|
||
Request $request = null,
|
||
Timebox $timebox = null)
|
||
{
|
||
$this->name = $name;
|
||
$this->session = $session;
|
||
$this->request = $request;
|
||
$this->provider = $provider;
|
||
$this->timebox = $timebox ?: new Timebox;
|
||
}
|
||
|
||
/**
|
||
* Get the currently authenticated user.
|
||
*
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function user()
|
||
{
|
||
if ($this->loggedOut) {
|
||
return;
|
||
}
|
||
|
||
// If we've already retrieved the user for the current request we can just
|
||
// return it back immediately. We do not want to fetch the user data on
|
||
// every call to this method because that would be tremendously slow.
|
||
if (! is_null($this->user)) {
|
||
return $this->user;
|
||
}
|
||
|
||
$id = $this->session->get($this->getName());
|
||
|
||
// First we will try to load the user using the identifier in the session if
|
||
// one exists. Otherwise we will check for a "remember me" cookie in this
|
||
// request, and if one exists, attempt to retrieve the user using that.
|
||
if (! is_null($id) && $this->user = $this->provider->retrieveById($id)) {
|
||
$this->fireAuthenticatedEvent($this->user);
|
||
}
|
||
|
||
// If the user is null, but we decrypt a "recaller" cookie we can attempt to
|
||
// pull the user data on that cookie which serves as a remember cookie on
|
||
// the application. Once we have a user we can return it to the caller.
|
||
if (is_null($this->user) && ! is_null($recaller = $this->recaller())) {
|
||
$this->user = $this->userFromRecaller($recaller);
|
||
|
||
if ($this->user) {
|
||
$this->updateSession($this->user->getAuthIdentifier());
|
||
|
||
$this->fireLoginEvent($this->user, true);
|
||
}
|
||
}
|
||
|
||
return $this->user;
|
||
}
|
||
|
||
/**
|
||
* Pull a user from the repository by its "remember me" cookie token.
|
||
*
|
||
* @param \Illuminate\Auth\Recaller $recaller
|
||
* @return mixed
|
||
*/
|
||
protected function userFromRecaller($recaller)
|
||
{
|
||
if (! $recaller->valid() || $this->recallAttempted) {
|
||
return;
|
||
}
|
||
|
||
// If the user is null, but we decrypt a "recaller" cookie we can attempt to
|
||
// pull the user data on that cookie which serves as a remember cookie on
|
||
// the application. Once we have a user we can return it to the caller.
|
||
$this->recallAttempted = true;
|
||
|
||
$this->viaRemember = ! is_null($user = $this->provider->retrieveByToken(
|
||
$recaller->id(), $recaller->token()
|
||
));
|
||
|
||
return $user;
|
||
}
|
||
|
||
/**
|
||
* Get the decrypted recaller cookie for the request.
|
||
*
|
||
* @return \Illuminate\Auth\Recaller|null
|
||
*/
|
||
protected function recaller()
|
||
{
|
||
if (is_null($this->request)) {
|
||
return;
|
||
}
|
||
|
||
if ($recaller = $this->request->cookies->get($this->getRecallerName())) {
|
||
return new Recaller($recaller);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get the ID for the currently authenticated user.
|
||
*
|
||
* @return int|string|null
|
||
*/
|
||
public function id()
|
||
{
|
||
if ($this->loggedOut) {
|
||
return;
|
||
}
|
||
|
||
return $this->user()
|
||
? $this->user()->getAuthIdentifier()
|
||
: $this->session->get($this->getName());
|
||
}
|
||
|
||
/**
|
||
* Log a user into the application without sessions or cookies.
|
||
*
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
public function once(array $credentials = [])
|
||
{
|
||
$this->fireAttemptEvent($credentials);
|
||
|
||
if ($this->validate($credentials)) {
|
||
$this->setUser($this->lastAttempted);
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Log the given user ID into the application without sessions or cookies.
|
||
*
|
||
* @param mixed $id
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|false
|
||
*/
|
||
public function onceUsingId($id)
|
||
{
|
||
if (! is_null($user = $this->provider->retrieveById($id))) {
|
||
$this->setUser($user);
|
||
|
||
return $user;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Validate a user's credentials.
|
||
*
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
public function validate(array $credentials = [])
|
||
{
|
||
$this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);
|
||
|
||
return $this->hasValidCredentials($user, $credentials);
|
||
}
|
||
|
||
/**
|
||
* Attempt to authenticate using HTTP Basic Auth.
|
||
*
|
||
* @param string $field
|
||
* @param array $extraConditions
|
||
* @return \Symfony\Component\HttpFoundation\Response|null
|
||
*/
|
||
public function basic($field = 'email', $extraConditions = [])
|
||
{
|
||
if ($this->check()) {
|
||
return;
|
||
}
|
||
|
||
// If a username is set on the HTTP basic request, we will return out without
|
||
// interrupting the request lifecycle. Otherwise, we'll need to generate a
|
||
// request indicating that the given credentials were invalid for login.
|
||
if ($this->attemptBasic($this->getRequest(), $field, $extraConditions)) {
|
||
return;
|
||
}
|
||
|
||
return $this->failedBasicResponse();
|
||
}
|
||
|
||
/**
|
||
* Perform a stateless HTTP Basic login attempt.
|
||
*
|
||
* @param string $field
|
||
* @param array $extraConditions
|
||
* @return \Symfony\Component\HttpFoundation\Response|null
|
||
*/
|
||
public function onceBasic($field = 'email', $extraConditions = [])
|
||
{
|
||
$credentials = $this->basicCredentials($this->getRequest(), $field);
|
||
|
||
if (! $this->once(array_merge($credentials, $extraConditions))) {
|
||
return $this->failedBasicResponse();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Attempt to authenticate using basic authentication.
|
||
*
|
||
* @param \Symfony\Component\HttpFoundation\Request $request
|
||
* @param string $field
|
||
* @param array $extraConditions
|
||
* @return bool
|
||
*/
|
||
protected function attemptBasic(Request $request, $field, $extraConditions = [])
|
||
{
|
||
if (! $request->getUser()) {
|
||
return false;
|
||
}
|
||
|
||
return $this->attempt(array_merge(
|
||
$this->basicCredentials($request, $field), $extraConditions
|
||
));
|
||
}
|
||
|
||
/**
|
||
* Get the credential array for an HTTP Basic request.
|
||
*
|
||
* @param \Symfony\Component\HttpFoundation\Request $request
|
||
* @param string $field
|
||
* @return array
|
||
*/
|
||
protected function basicCredentials(Request $request, $field)
|
||
{
|
||
return [$field => $request->getUser(), 'password' => $request->getPassword()];
|
||
}
|
||
|
||
/**
|
||
* Get the response for basic authentication.
|
||
*
|
||
* @return void
|
||
*
|
||
* @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
|
||
*/
|
||
protected function failedBasicResponse()
|
||
{
|
||
throw new UnauthorizedHttpException('Basic', 'Invalid credentials.');
|
||
}
|
||
|
||
/**
|
||
* Attempt to authenticate a user using the given credentials.
|
||
*
|
||
* @param array $credentials
|
||
* @param bool $remember
|
||
* @return bool
|
||
*/
|
||
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;
|
||
}
|
||
|
||
/**
|
||
* Attempt to authenticate a user with credentials and additional callbacks.
|
||
*
|
||
* @param array $credentials
|
||
* @param array|callable $callbacks
|
||
* @param false $remember
|
||
* @return bool
|
||
*/
|
||
public function attemptWhen(array $credentials = [], $callbacks = null, $remember = false)
|
||
{
|
||
$this->fireAttemptEvent($credentials, $remember);
|
||
|
||
$this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);
|
||
|
||
// This method does the exact same thing as attempt, but also executes callbacks after
|
||
// the user is retrieved and validated. If one of the callbacks returns falsy we do
|
||
// not login the user. Instead, we will fail the specific authentication attempt.
|
||
if ($this->hasValidCredentials($user, $credentials) && $this->shouldLogin($callbacks, $user)) {
|
||
$this->login($user, $remember);
|
||
|
||
return true;
|
||
}
|
||
|
||
$this->fireFailedEvent($user, $credentials);
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Determine if the user matches the credentials.
|
||
*
|
||
* @param mixed $user
|
||
* @param array $credentials
|
||
* @return bool
|
||
*/
|
||
protected function hasValidCredentials($user, $credentials)
|
||
{
|
||
return $this->timebox->call(function ($timebox) use ($user, $credentials) {
|
||
$validated = ! is_null($user) && $this->provider->validateCredentials($user, $credentials);
|
||
|
||
if ($validated) {
|
||
$timebox->returnEarly();
|
||
|
||
$this->fireValidatedEvent($user);
|
||
}
|
||
|
||
return $validated;
|
||
}, 200 * 1000);
|
||
}
|
||
|
||
/**
|
||
* Determine if the user should login by executing the given callbacks.
|
||
*
|
||
* @param array|callable|null $callbacks
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return bool
|
||
*/
|
||
protected function shouldLogin($callbacks, AuthenticatableContract $user)
|
||
{
|
||
foreach (Arr::wrap($callbacks) as $callback) {
|
||
if (! $callback($user, $this)) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* Log the given user ID into the application.
|
||
*
|
||
* @param mixed $id
|
||
* @param bool $remember
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|false
|
||
*/
|
||
public function loginUsingId($id, $remember = false)
|
||
{
|
||
if (! is_null($user = $this->provider->retrieveById($id))) {
|
||
$this->login($user, $remember);
|
||
|
||
return $user;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Log a user into the application.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @param bool $remember
|
||
* @return void
|
||
*/
|
||
public function login(AuthenticatableContract $user, $remember = false)
|
||
{
|
||
$this->updateSession($user->getAuthIdentifier());
|
||
|
||
// If the user should be permanently "remembered" by the application we will
|
||
// queue a permanent cookie that contains the encrypted copy of the user
|
||
// identifier. We will then decrypt this later to retrieve the users.
|
||
if ($remember) {
|
||
$this->ensureRememberTokenIsSet($user);
|
||
|
||
$this->queueRecallerCookie($user);
|
||
}
|
||
|
||
// If we have an event dispatcher instance set we will fire an event so that
|
||
// any listeners will hook into the authentication events and run actions
|
||
// based on the login and logout events fired from the guard instances.
|
||
$this->fireLoginEvent($user, $remember);
|
||
|
||
$this->setUser($user);
|
||
}
|
||
|
||
/**
|
||
* Update the session with the given ID.
|
||
*
|
||
* @param string $id
|
||
* @return void
|
||
*/
|
||
protected function updateSession($id)
|
||
{
|
||
$this->session->put($this->getName(), $id);
|
||
|
||
$this->session->migrate(true);
|
||
}
|
||
|
||
/**
|
||
* Create a new "remember me" token for the user if one doesn't already exist.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
protected function ensureRememberTokenIsSet(AuthenticatableContract $user)
|
||
{
|
||
if (empty($user->getRememberToken())) {
|
||
$this->cycleRememberToken($user);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Queue the recaller cookie into the cookie jar.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
protected function queueRecallerCookie(AuthenticatableContract $user)
|
||
{
|
||
$this->getCookieJar()->queue($this->createRecaller(
|
||
$user->getAuthIdentifier().'|'.$user->getRememberToken().'|'.$user->getAuthPassword()
|
||
));
|
||
}
|
||
|
||
/**
|
||
* Create a "remember me" cookie for a given ID.
|
||
*
|
||
* @param string $value
|
||
* @return \Symfony\Component\HttpFoundation\Cookie
|
||
*/
|
||
protected function createRecaller($value)
|
||
{
|
||
return $this->getCookieJar()->make($this->getRecallerName(), $value, $this->getRememberDuration());
|
||
}
|
||
|
||
/**
|
||
* Log the user out of the application.
|
||
*
|
||
* @return void
|
||
*/
|
||
public function logout()
|
||
{
|
||
$user = $this->user();
|
||
|
||
$this->clearUserDataFromStorage();
|
||
|
||
if (! is_null($this->user) && ! empty($user->getRememberToken())) {
|
||
$this->cycleRememberToken($user);
|
||
}
|
||
|
||
// If we have an event dispatcher instance, we can fire off the logout event
|
||
// so any further processing can be done. This allows the developer to be
|
||
// listening for anytime a user signs out of this application manually.
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new Logout($this->name, $user));
|
||
}
|
||
|
||
// Once we have fired the logout event we will clear the users out of memory
|
||
// so they are no longer available as the user is no longer considered as
|
||
// being signed into this application and should not be available here.
|
||
$this->user = null;
|
||
|
||
$this->loggedOut = true;
|
||
}
|
||
|
||
/**
|
||
* Log the user out of the application on their current device only.
|
||
*
|
||
* This method does not cycle the "remember" token.
|
||
*
|
||
* @return void
|
||
*/
|
||
public function logoutCurrentDevice()
|
||
{
|
||
$user = $this->user();
|
||
|
||
$this->clearUserDataFromStorage();
|
||
|
||
// If we have an event dispatcher instance, we can fire off the logout event
|
||
// so any further processing can be done. This allows the developer to be
|
||
// listening for anytime a user signs out of this application manually.
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new CurrentDeviceLogout($this->name, $user));
|
||
}
|
||
|
||
// Once we have fired the logout event we will clear the users out of memory
|
||
// so they are no longer available as the user is no longer considered as
|
||
// being signed into this application and should not be available here.
|
||
$this->user = null;
|
||
|
||
$this->loggedOut = true;
|
||
}
|
||
|
||
/**
|
||
* Remove the user data from the session and cookies.
|
||
*
|
||
* @return void
|
||
*/
|
||
protected function clearUserDataFromStorage()
|
||
{
|
||
$this->session->remove($this->getName());
|
||
|
||
if (! is_null($this->recaller())) {
|
||
$this->getCookieJar()->queue($this->getCookieJar()
|
||
->forget($this->getRecallerName()));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Refresh the "remember me" token for the user.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
protected function cycleRememberToken(AuthenticatableContract $user)
|
||
{
|
||
$user->setRememberToken($token = Str::random(60));
|
||
|
||
$this->provider->updateRememberToken($user, $token);
|
||
}
|
||
|
||
/**
|
||
* Invalidate other sessions for the current user.
|
||
*
|
||
* The application must be using the AuthenticateSession middleware.
|
||
*
|
||
* @param string $password
|
||
* @param string $attribute
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*
|
||
* @throws \Illuminate\Auth\AuthenticationException
|
||
*/
|
||
public function logoutOtherDevices($password, $attribute = 'password')
|
||
{
|
||
if (! $this->user()) {
|
||
return;
|
||
}
|
||
|
||
$result = $this->rehashUserPassword($password, $attribute);
|
||
|
||
if ($this->recaller() ||
|
||
$this->getCookieJar()->hasQueued($this->getRecallerName())) {
|
||
$this->queueRecallerCookie($this->user());
|
||
}
|
||
|
||
$this->fireOtherDeviceLogoutEvent($this->user());
|
||
|
||
return $result;
|
||
}
|
||
|
||
/**
|
||
* Rehash the current user's password.
|
||
*
|
||
* @param string $password
|
||
* @param string $attribute
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*
|
||
* @throws \InvalidArgumentException
|
||
*/
|
||
protected function rehashUserPassword($password, $attribute)
|
||
{
|
||
if (! Hash::check($password, $this->user()->{$attribute})) {
|
||
throw new InvalidArgumentException('The given password does not match the current password.');
|
||
}
|
||
|
||
return tap($this->user()->forceFill([
|
||
$attribute => Hash::make($password),
|
||
]))->save();
|
||
}
|
||
|
||
/**
|
||
* Register an authentication attempt event listener.
|
||
*
|
||
* @param mixed $callback
|
||
* @return void
|
||
*/
|
||
public function attempting($callback)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->listen(Events\Attempting::class, $callback);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fire the attempt event with the arguments.
|
||
*
|
||
* @param array $credentials
|
||
* @param bool $remember
|
||
* @return void
|
||
*/
|
||
protected function fireAttemptEvent(array $credentials, $remember = false)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new Attempting(
|
||
$this->name, $credentials, $remember
|
||
));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fires the validated event if the dispatcher is set.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
protected function fireValidatedEvent($user)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new Validated(
|
||
$this->name, $user
|
||
));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fire the login event if the dispatcher is set.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @param bool $remember
|
||
* @return void
|
||
*/
|
||
protected function fireLoginEvent($user, $remember = false)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new Login(
|
||
$this->name, $user, $remember
|
||
));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fire the authenticated event if the dispatcher is set.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
protected function fireAuthenticatedEvent($user)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new Authenticated(
|
||
$this->name, $user
|
||
));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fire the other device logout event if the dispatcher is set.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return void
|
||
*/
|
||
protected function fireOtherDeviceLogoutEvent($user)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new OtherDeviceLogout(
|
||
$this->name, $user
|
||
));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Fire the failed authentication attempt event with the given arguments.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable|null $user
|
||
* @param array $credentials
|
||
* @return void
|
||
*/
|
||
protected function fireFailedEvent($user, array $credentials)
|
||
{
|
||
if (isset($this->events)) {
|
||
$this->events->dispatch(new Failed(
|
||
$this->name, $user, $credentials
|
||
));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get the last user we attempted to authenticate.
|
||
*
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable
|
||
*/
|
||
public function getLastAttempted()
|
||
{
|
||
return $this->lastAttempted;
|
||
}
|
||
|
||
/**
|
||
* Get a unique identifier for the auth session value.
|
||
*
|
||
* @return string
|
||
*/
|
||
public function getName()
|
||
{
|
||
return 'login_'.$this->name.'_'.sha1(static::class);
|
||
}
|
||
|
||
/**
|
||
* Get the name of the cookie used to store the "recaller".
|
||
*
|
||
* @return string
|
||
*/
|
||
public function getRecallerName()
|
||
{
|
||
return 'remember_'.$this->name.'_'.sha1(static::class);
|
||
}
|
||
|
||
/**
|
||
* Determine if the user was authenticated via "remember me" cookie.
|
||
*
|
||
* @return bool
|
||
*/
|
||
public function viaRemember()
|
||
{
|
||
return $this->viaRemember;
|
||
}
|
||
|
||
/**
|
||
* Get the number of minutes the remember me cookie should be valid for.
|
||
*
|
||
* @return int
|
||
*/
|
||
protected function getRememberDuration()
|
||
{
|
||
return $this->rememberDuration;
|
||
}
|
||
|
||
/**
|
||
* Set the number of minutes the remember me cookie should be valid for.
|
||
*
|
||
* @param int $minutes
|
||
* @return $this
|
||
*/
|
||
public function setRememberDuration($minutes)
|
||
{
|
||
$this->rememberDuration = $minutes;
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* Get the cookie creator instance used by the guard.
|
||
*
|
||
* @return \Illuminate\Contracts\Cookie\QueueingFactory
|
||
*
|
||
* @throws \RuntimeException
|
||
*/
|
||
public function getCookieJar()
|
||
{
|
||
if (! isset($this->cookie)) {
|
||
throw new RuntimeException('Cookie jar has not been set.');
|
||
}
|
||
|
||
return $this->cookie;
|
||
}
|
||
|
||
/**
|
||
* Set the cookie creator instance used by the guard.
|
||
*
|
||
* @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie
|
||
* @return void
|
||
*/
|
||
public function setCookieJar(CookieJar $cookie)
|
||
{
|
||
$this->cookie = $cookie;
|
||
}
|
||
|
||
/**
|
||
* Get the event dispatcher instance.
|
||
*
|
||
* @return \Illuminate\Contracts\Events\Dispatcher
|
||
*/
|
||
public function getDispatcher()
|
||
{
|
||
return $this->events;
|
||
}
|
||
|
||
/**
|
||
* Set the event dispatcher instance.
|
||
*
|
||
* @param \Illuminate\Contracts\Events\Dispatcher $events
|
||
* @return void
|
||
*/
|
||
public function setDispatcher(Dispatcher $events)
|
||
{
|
||
$this->events = $events;
|
||
}
|
||
|
||
/**
|
||
* Get the session store used by the guard.
|
||
*
|
||
* @return \Illuminate\Contracts\Session\Session
|
||
*/
|
||
public function getSession()
|
||
{
|
||
return $this->session;
|
||
}
|
||
|
||
/**
|
||
* Return the currently cached user.
|
||
*
|
||
* @return \Illuminate\Contracts\Auth\Authenticatable|null
|
||
*/
|
||
public function getUser()
|
||
{
|
||
return $this->user;
|
||
}
|
||
|
||
/**
|
||
* Set the current user.
|
||
*
|
||
* @param \Illuminate\Contracts\Auth\Authenticatable $user
|
||
* @return $this
|
||
*/
|
||
public function setUser(AuthenticatableContract $user)
|
||
{
|
||
$this->user = $user;
|
||
|
||
$this->loggedOut = false;
|
||
|
||
$this->fireAuthenticatedEvent($user);
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* Get the current request instance.
|
||
*
|
||
* @return \Symfony\Component\HttpFoundation\Request
|
||
*/
|
||
public function getRequest()
|
||
{
|
||
return $this->request ?: Request::createFromGlobals();
|
||
}
|
||
|
||
/**
|
||
* Set the current request instance.
|
||
*
|
||
* @param \Symfony\Component\HttpFoundation\Request $request
|
||
* @return $this
|
||
*/
|
||
public function setRequest(Request $request)
|
||
{
|
||
$this->request = $request;
|
||
|
||
return $this;
|
||
}
|
||
|
||
/**
|
||
* Get the timebox instance used by the guard.
|
||
*
|
||
* @return \Illuminate\Support\Timebox
|
||
*/
|
||
public function getTimebox()
|
||
{
|
||
return $this->timebox;
|
||
}
|
||
}
|
||
|
||
``` |