Auth utilise du sel et un mot de passe pour les exemples d'authentification des utilisateurs

Cet article vous présente principalement les informations pertinentes sur l'utilisation de salt et d'un mot de passe pour authentifier les utilisateurs en modifiant Laravel Auth. L'article le présente en détail à travers l'exemple de code. Il a une certaine valeur de référence pour l'étude ou le travail de chacun. peut aider.

Le système d'authentification des utilisateurs de Laraval, Auth, est très puissant et facile à utiliser. Cependant, dans le système d'authentification des utilisateurs de Laravel, les algorithmes de cryptage et d'authentification des mots de passe sont utilisés dans des modules tels que l'enregistrement des utilisateurs, la connexion et la récupération du mot de passe. et de nombreux projets précédents utilisent la méthode de stockage des chaînes cryptées salt + password pour enregistrer les mots de passe des utilisateurs dans la table user. Cela a apporté une grande résistance à l'utilisation du framework Laravel pour reconstruire les projets précédents. Cependant, j'ai récemment terminé la modification de Laravel Auth en effectuant une recherche. pour des informations sur Internet, la lecture des forums communautaires et la lecture du code source, j'espère qu'il sera utile aux autres en le partageant ici. Avant de commencer, je dois expliquer que si le framework Laravel est utilisé dans un nouveau projet, il n'est pas nécessaire d'apporter des modifications à Auth. L'algorithme de chiffrement bcrypt par défaut est un algorithme de chiffrement plus sécurisé et plus efficace que salt + password.

Modifier l'enregistrement de l'utilisateur

Tout d'abord, activez la vérification dans Laravel à l'aide de la commande artisanale

php artisan make:auth

Après avoir exécuté la commande, ajoutez-la au fichier routes (emplacement : app /Http/routes.php) aura un appel de méthode statique supplémentaire

Route::auth();

Cette route est une façade de Laravel (située dans IlluminateSupportFacadesRoute), et la méthode auth appelée est définie dans la classe IlluminateRoutingRouter. Vous pouvez voir la méthode d'authentification comme suit Voici quelques règles de routage liées à Auth définies

/**
 * Register the typical authentication routes for an application.
 *
 * @return void
 */
public function auth()
{
 // Authentication Routes...
 $this->get('login', 'Auth\AuthController@showLoginForm');
 $this->post('login', 'Auth\AuthController@login');
 $this->get('logout', 'Auth\AuthController@logout');

 // Registration Routes...
 $this->get('register', 'Auth\AuthController@showRegistrationForm');
 $this->post('register', 'Auth\AuthController@register');

 // Password Reset Routes...
 $this->get('password/reset/{token?}', 'Auth\PasswordController@showResetForm');
 $this->post('password/email', 'Auth\PasswordController@sendResetLinkEmail');
 $this->post('password/reset', 'Auth\PasswordController@reset');
}

Grâce aux règles de routage, vous pouvez voir que la méthode de contrôleur demandée lors de l'enregistrement est la méthode de registre d'AuthController. est défini dans les traits de IlluminateFoundationAuthRegistersUsers. AuthController est dans la classe. Ce trait est introduit dans la définition

/**
 * Handle a registration request for the application.
 *
 * @param \Illuminate\Http\Request $request
 * @return \Illuminate\Http\Response
 */
public function register(Request $request)
{
 $validator = $this->validator($request->all());

 if ($validator->fails()) {
 $this->throwValidationException(
  $request, $validator
 );
 }

 Auth::guard($this->getGuard())->login($this->create($request->all()));

 return redirect($this->redirectPath());
}

Dans la méthode de registre, les données saisies par l'utilisateur dans la requête seront d'abord vérifiées. pour définir votre propre vérification de chaque champ de saisie dans la méthode de validation d'AuthController. Les règles peuvent être

protected function validator(array $data)
{
 return Validator::make($data, [
 'name' => 'required|max:255',
 'email' => 'required|email|max:255|unique:user',
 'password' => 'required|size:40|confirmed',
 ]);
}

puis regarder vers le bas. Une fois la vérification réussie, Laravel utilisera la méthode create d'AuthController pour générer. un nouvel utilisateur, puis utilisez les données du nouvel utilisateur pour vous connecter à Auth::guard($this- >getGuard())->login($this->create($request->all()) );

Nous devons donc personnaliser la méthode de cryptage pour générer les mots de passe des utilisateurs lors de l'inscription. Vous devez modifier la méthode de création d'AuthController.

Par exemple :

/**
 * Create a new user instance after a valid registration.
 *
 * @param array $data
 * @return User
 */
protected function create(array $data)
{
 $salt = Str::random(6);
 return User::create([
 'nickname' => $data['name'],
 'email' => $data['email'],
 'password' => sha1($salt . $data['password']),
 'register_time' => time(),
 'register_ip' => ip2long(request()->ip()),
 'salt' => $salt
 ]);
}

Modifier la connexion de l'utilisateur

Avant de modifier la connexion, nous devons d'abord examiner le contrôleur spécifique de la demande de connexion grâce aux règles et à la méthode de routage, vous pouvez voir dans la définition de la méthode d'authentification mentionnée ci-dessus que l'opération de vérification de la connexion se trouve dans la méthode de connexion de la classe AppHttpControllersAuthAuthController. Ouvrez AuthController et constatez que les méthodes liées à Auth sont introduites dans la classe via les traits. Lors de la compilation, PHP copiera le code des traits dans la classe. les scénarios applicables et les utilisations des fonctionnalités introduites ne seront pas détaillés ici. Ainsi, la méthode AuthController@login est en fait définie dans les traits

IlluminateFoundationAuthAuthenticatesUsers

 $this->get('login', 'Auth\AuthController@showLoginForm');
 $this->post('login', 'Auth\AuthController@login');
 $this->get('logout', 'Auth\AuthController@logout');

L'opération principale de vérification de connexion est Auth::guard($this->getGuard())-> tentative($credentials, $request->has('remember')); Cette méthode est appelée, et Auth::guard($this->getGuard()) obtient IlluminateAuthSessionGuard (en particulier comment l'obtenir) Regardez le code source dans Auth Facade IlluminateAuthAuthManager)

/**
 * Handle a login request to the application.
 *
 * @param \Illuminate\Http\Request $request
 * @return \Illuminate\Http\Response
 */
public function login(Request $request)
{
 $this->validateLogin($request);
 $throttles = $this->isUsingThrottlesLoginsTrait();

 if ($throttles && $lockedOut = $this->hasTooManyLoginAttempts($request)) {
 $this->fireLockoutEvent($request);

 return $this->sendLockoutResponse($request);
 }

 $credentials = $this->getCredentials($request);

 if (Auth::guard($this->getGuard())->attempt($credentials, $request->has('remember'))) {
 return $this->handleUserWasAuthenticated($request, $throttles);
 }

 if ($throttles && ! $lockedOut) {
 $this->incrementLoginAttempts($request);
 }

 return $this->sendFailedLoginResponse($request);
}

Regardez comment la méthode de tentative dans SessionGuard est implémentée :

retrieveByCredentials utilise les champs transmis pour récupérer les données utilisateur de la base de données validateCredentials. le processus réel utilisé pour vérifier que le mot de passe est correct.

public function attempt(array $credentials = [], $remember = false, $login = true)
{
 $this->fireAttemptEvent($credentials, $remember, $login);

 $this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);

 if ($this->hasValidCredentials($user, $credentials)) {
 if ($login) {
  $this->login($user, $remember);
 }

 return true;
 }

 if ($login) {
 $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 ! is_null($user) && $this->provider->validateCredentials($user, $credentials);
}

Ce qu'il faut noter ici, c'est que $this->provider est un fournisseur qui implémente la classe IlluminateContractsAuthUserProvider. Nous voyons qu'il existe deux implémentations de UserProvider sous le répertoire IlluminateAuth, à savoir DatabaseUserProvider et EloquentUserProvider, mais nous vérifions. Lequel est utilisé pour vérifier le mot de passe ? Jetez un œil au fichier de configuration d'authentification

Le driver => eloquent est configuré ici, il est donc vérifié via le retrieveByCredentials d'EloquentUserProvider. Cet EloquentUserProvider est dans SessionGuard. est injecté lorsqu'il est instancié. (Pour plus de détails sur la façon de lire le fichier de configuration d'authentification et d'instancier le fournisseur correspondant et de l'injecter dans SessionGuard, veuillez vous référer au code source de la méthode createSessionDriver dans IlluminateAuthAuthManager)

'providers' => [
 'users' => [
 'driver' => 'eloquent',
 'model' => App\User::class, //这个是driver用的Model
 ],
],

Ensuite, nous continue Découvrez l'implémentation des méthodes retrieveByCredentials et validateCredentials dans EloquentUserProvider :

Les deux méthodes ci-dessus retrieveByCredentials utilisent des champs autres que les mots de passe pour récupérer les enregistrements utilisateur de la table utilisateur de la base de données, par exemple en utilisant le courrier électronique pour interroger l'utilisateur enregistrements, puis la méthode validateCredentials. Utilisez simplement $this->haser->check pour comparer le mot de passe saisi avec le mot de passe haché afin de vérifier si le mot de passe est correct.

好了， 看到这里就很明显了， 我们需要改成自己的密码验证就是自己实现一下validateCredentials就可以了， 修改$this->hasher->check为我们自己的密码验证规则就可以了。

首先我们修改$user->getAuthPassword()把数据库中用户表的salt和password传递到validateCredentials中
修改App\User.php 添加如下代码

/**
 * The table associated to this model
 */
protected $table = 'user';／／用户表名不是laravel约定的这里要指定一下

/**
 * 禁用Laravel自动管理timestamp列
 */
public $timestamps = false;

/**
 * 覆盖Laravel中默认的getAuthPassword方法, 返回用户的password和salt字段
 * @return type
 */
public function getAuthPassword()
{
 return ['password' => $this->attributes['password'], 'salt' => $this->attributes['salt']];
}

然后我们在建立一个自己的UserProvider接口的实现，放到自定义的目录中：

新建app/Foundation/Auth/AdminEloquentUserProvider.php

namespace App\Foundation\Auth;

use Illuminate\Auth\EloquentUserProvider;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Support\Str;

class AdminEloquentUserProvider extends EloquentUserProvider
{

 /**
  * Validate a user against the given credentials.
  *
  * @param \Illuminate\Contracts\Auth\Authenticatable $user
  * @param array $credentials
  */
 public function validateCredentials(Authenticatable $user, array $credentials) {
  $plain = $credentials['password'];
  $authPassword = $user->getAuthPassword();

  return sha1($authPassword['salt'] . $plain) == $authPassword['password'];
 }
}

最后我们修改auth配置文件让Laravel在做Auth验证时使用我们刚定义的Provider，
修改config/auth.php：

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

修改app/Provider/AuthServiceProvider.php

public function boot(GateContract $gate)
{
 $this->registerPolicies($gate);

 \Auth::provider('admin-eloquent', function ($app, $config) {
  return New \App\Foundation\Auth\AdminEloquentUserProvider($app['hash'], $config['model']);
 });
}

Auth::provider方法是用来注册Provider构造器的，这个构造器是一个Closure，provider方法的具体代码实现在AuthManager文件里

public function provider($name, Closure $callback)
{
 $this->customProviderCreators[$name] = $callback;

 return $this;
}

闭包返回了AdminEloquentUserProvider对象供Laravel Auth使用，好了做完这些修改后Laravel的Auth在做用户登录验证的时候采用的就是自定义的salt + password的方式了。

修改重置密码

Laravel 的重置密码的工作流程是：

• 向需要重置密码的用户的邮箱发送一封带有重置密码链接的邮件，链接中会包含用户的email地址和token。

• 用户点击邮件中的链接在重置密码页面输入新的密码，Laravel通过验证email和token确认用户就是发起重置密码请求的用户后将新密码更新到用户在数据表的记录里。

第一步需要配置Laravel的email功能，此外还需要在数据库中创建一个新表password_resets来存储用户的email和对应的token

CREATE TABLE `password_resets` (
 `email` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
 `token` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
 `created_at` timestamp NOT NULL,
 KEY `password_resets_email_index` (`email`),
 KEY `password_resets_token_index` (`token`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

通过重置密码表单的提交地址可以看到，表单把新的密码用post提交给了/password/reset，我们先来看一下auth相关的路由，确定/password/reset对应的控制器方法。

 $this->post('password/reset', 'Auth\PasswordController@reset');

可以看到对应的控制器方法是\App\Http\Controllers\Auth\PasswordController类的reset方法，这个方法实际是定义在\Illuminate\Foundation\Auth\ResetsPasswords 这个traits里，PasswordController引入了这个traits

/**
 * Reset the given user's password.
 *
 * @param \Illuminate\Http\Request $request
 * @return \Illuminate\Http\Response
 */
public function reset(Request $request)
{
 $this->validate(
  $request,
  $this->getResetValidationRules(),
  $this->getResetValidationMessages(),
  $this->getResetValidationCustomAttributes()
 );

 $credentials = $this->getResetCredentials($request);

 $broker = $this->getBroker();

 $response = Password::broker($broker)->reset($credentials, function ($user, $password) {
  $this->resetPassword($user, $password);
 });

 switch ($response) {
  case Password::PASSWORD_RESET:
   return $this->getResetSuccessResponse($response);
  default:
   return $this->getResetFailureResponse($request, $response);
 }
}

方法开头先通过validator对输入进行验证,接下来在程序里传递把新密码和一个闭包对象传递给Password::broker($broker)->reset();方法，这个方法定义在\Illuminate\Auth\Passwords\PasswordBroker类里.

/**
 * Reset the password for the given token.
 *
 * @param array $credentials
 * @param \Closure $callback
 * @return mixed
 */
public function reset(array $credentials, Closure $callback)
{
 // If the responses from the validate method is not a user instance, we will
 // assume that it is a redirect and simply return it from this method and
 // the user is properly redirected having an error message on the post.
 $user = $this->validateReset($credentials);

 if (! $user instanceof CanResetPasswordContract) {
  return $user;
 }

 $pass = $credentials['password'];

 // Once we have called this callback, we will remove this token row from the
 // table and return the response from this callback so the user gets sent
 // to the destination given by the developers from the callback return.
 call_user_func($callback, $user, $pass);

 $this->tokens->delete($credentials['token']);

 return static::PASSWORD_RESET;
}

在PasswordBroker的reset方法里，程序会先对用户提交的数据做再一次的认证，然后把密码和用户实例传递给传递进来的闭包，在闭包调用里完成了将新密码更新到用户表的操作， 在闭包里程序调用了的PasswrodController类的resetPassword方法

function ($user, $password) {
 $this->resetPassword($user, $password);
});

PasswrodController类resetPassword方法的定义

protected function resetPassword($user, $password)
{
 $user->forceFill([
  'password' => bcrypt($password),
  'remember_token' => Str::random(60),
 ])->save();

 Auth::guard($this->getGuard())->login($user);
}

在这个方法里Laravel 用的是bcrypt 加密了密码， 那么要改成我们需要的salt + password的方式，我们在PasswordController类里重写resetPassword方法覆盖掉traits里的该方法就可以了。

/**
 * 覆盖ResetsPasswords traits里的resetPassword方法,改为用sha1(salt + password)的加密方式
 * Reset the given user's password.
 *
 * @param \Illuminate\Contracts\Auth\CanResetPassword $user
 * @param string $password
 * @return void
 */
protected function resetPassword($user, $password)
{
 $salt = Str::random(6);
 $user->forceFill([
  'password' => sha1($salt . $password),
  'salt' => $salt,
  'remember_token' => Str::random(60),
 ])->save();

 \Auth::guard($this->getGuard())->login($user);
}

结语

到这里对Laravel Auth的自定义就完成了，注册、登录和重置密码都改成了sha1(salt + password)的密码加密方式， 所有自定义代码都是通过定义Laravel相关类的子类和重写方法来完成没有修改Laravel的源码，这样既保持了良好的可扩展性也保证了项目能够自由迁移。

注：使用的Laravel版本为5.2

相关推荐：

Laravel5.5中利用Passport实现Auth认证的方法

详解Laravel框架中的Auth模块

自己写的适配tp5的Auth验证demo

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!