Laravel 8 Fortify - 2FA только когда пользователь входит в систему с нового устройства

Я использую двухфакторную аутентификацию (2FA) в своем приложении Laravel 8.

Двухфакторная аутентификация применяется каждый раз, когда пользователь входит в систему. Однако я не считаю, что двухфакторная аутентификация необходима каждый раз, меня это даже раздражает. В качестве решения я думаю применять его только тогда, когда пользователь подключается с нового устройства. Есть ли кто-нибудь, кто уже сделал это, или кто может дать мне подсказку о необходимых изменениях?

2 ответа

У меня есть его. Вот шаги, которые я выполнил:

  1. В конфигурационном файле fortify.php я добавил

            'pipelines' => [
        'login' => [
            App\Actions\Fortify\RedirectIfTwoFactorAuthenticatable::class,
            Laravel\Fortify\Actions\AttemptToAuthenticate::class,
            Laravel\Fortify\Actions\PrepareAuthenticatedSession::class,
        ]
    ]
    
  2. Я добавил поле two_factor_cookies в класс User.

  3. Я настроил класс FortifyRedirectIfTwoFactorAuthenticatable:

            <?php
    
    namespace App\Actions\Fortify;
    
    use Laravel\Fortify\Actions\RedirectIfTwoFactorAuthenticatable as DefaultRedirectIfTwoFactorAuthenticatable;
    use Laravel\Fortify\TwoFactorAuthenticatable;
    
    
    class RedirectIfTwoFactorAuthenticatable extends DefaultRedirectIfTwoFactorAuthenticatable
    {
    
        /**
         * Handle the incoming request.
         *
         * @param  \Illuminate\Http\Request  $request
         * @param  callable  $next
         * @return mixed
         */
        public function handle($request, $next)
        {
            $user = $this->validateCredentials($request);
    
            if (optional($user)->two_factor_secret &&
                in_array(TwoFactorAuthenticatable::class, class_uses_recursive($user)) &&
                $this->checkIfUserDeviceHasNotCookie($user)) {
                return $this->twoFactorChallengeResponse($request, $user);
            }
    
            return $next($request);
        }
    
        /**
         * This checks if the user's device has the cookie stored 
         * in the database.
         *
         * @param  \App\Models\User\User  $user
         * @return bool
         */
        protected function checkIfUserDeviceHasNotCookie($user)
        {
            $two_factor_cookies = json_decode($user->two_factor_cookies);
            if (!is_array($two_factor_cookies)){
                $two_factor_cookies = [];
            }
            $two_factor_cookie = \Cookie::get('2fa');
            return !in_array($two_factor_cookie,$two_factor_cookies);
        }
    
    }
    
  4. В FortifyServiceProvider я добавил настроенный TwoFactorLoginResponse.

                <?php
    
        namespace App\Providers;
    
        use App\Actions\Fortify\CreateNewUser;
        use App\Actions\Fortify\ResetUserPassword;
        use App\Actions\Fortify\UpdateUserPassword;
        use App\Actions\Fortify\UpdateUserProfileInformation;
        use App\Http\Responses\FailedPasswordResetLinkRequestResponse;
        use App\Http\Responses\FailedPasswordResetResponse;
        use App\Http\Responses\LockoutResponse;
        use App\Http\Responses\LoginResponse;
        use App\Http\Responses\LogoutResponse;
        use App\Http\Responses\PasswordResetResponse;
        use App\Http\Responses\RegisterResponse;
        use App\Http\Responses\SuccessfulPasswordResetLinkRequestResponse;
        use App\Http\Responses\TwoFactorLoginResponse;
        use App\Http\Responses\VerifyEmail;
        use Illuminate\Cache\RateLimiting\Limit;
        use Illuminate\Http\Request;
        use Illuminate\Support\Facades\RateLimiter;
        use Illuminate\Support\ServiceProvider;
        use Laravel\Fortify\Contracts\FailedPasswordResetLinkRequestResponse as FailedPasswordResetLinkRequestResponseContract;
        use Laravel\Fortify\Contracts\FailedPasswordResetResponse as FailedPasswordResetResponseContract;
        use Laravel\Fortify\Contracts\LockoutResponse as LockoutResponseContract;
        use Laravel\Fortify\Contracts\LoginResponse as LoginResponseContract;
        use Laravel\Fortify\Contracts\LogoutResponse as LogoutResponseContract;
        use Laravel\Fortify\Contracts\PasswordResetResponse as PasswordResetResponseContract;
        use Laravel\Fortify\Contracts\RegisterResponse as RegisterResponseContract;
        use Laravel\Fortify\Contracts\SuccessfulPasswordResetLinkRequestResponse as SuccessfulPasswordResetLinkRequestResponseContract;
        use Laravel\Fortify\Contracts\TwoFactorLoginResponse as TwoFactorLoginResponseContract;
        use Laravel\Fortify\Fortify;
    
        class FortifyServiceProvider extends ServiceProvider
        {
            /**
             * Register any application services.
             *
             * @return void
             */
            public function register()
            {
                $this->registerResponseBindings();
            }
    
            /**
             * Register the response bindings.
             *
             * @return void
             */
            protected function registerResponseBindings()
            {
                $this->app->singleton(LoginResponseContract::class, LoginResponse::class);
                $this->app->singleton(LogoutResponseContract::class, LogoutResponse::class);
                $this->app->singleton(TwoFactorLoginResponseContract::class, TwoFactorLoginResponse::class);
                $this->app->singleton(RegisterResponseContract::class, RegisterResponse::class);
    
                $this->app->singleton(LockoutResponseContract::class, LockoutResponse::class);
                $this->app->singleton(SuccessfulPasswordResetLinkRequestResponseContract::class, SuccessfulPasswordResetLinkRequestResponse::class);
                $this->app->singleton(FailedPasswordResetLinkRequestResponseContract::class, FailedPasswordResetLinkRequestResponse::class);
                $this->app->singleton(PasswordResetResponseContract::class, PasswordResetResponse::class);
                $this->app->singleton(FailedPasswordResetResponseContract::class, FailedPasswordResetResponse::class);        
            }
    
            /**
             * Bootstrap any application services.
             *
             * @return void
             */
            public function boot()
            {
    
                Fortify::ignoreRoutes();
                Fortify::loginView(function () {
                    return view('auth.login');
                });
                Fortify::twoFactorChallengeView('auth.two-factor-challenge');
                Fortify::confirmPasswordView(function (Request $request) {
                    if ($request->ajax()) {
                        return view('auth.confirm-password-form');
                    } else {
                        return view('auth.confirm-password');
                    }
                });
    
                Fortify::requestPasswordResetLinkView(function () {
                    return view('auth.forgot-password');
                });
                Fortify::resetPasswordView(function ($request) {
                    return view('auth.reset-password', ['request' => $request,'token' => $request->route('token')]);
                });
                Fortify::registerView(function () {
                    return view('auth.register'); 
                });
                Fortify::verifyEmailView(function () {
                    return view('auth.verify');
                });
    
                Fortify::createUsersUsing(CreateNewUser::class);
                Fortify::updateUserProfileInformationUsing(UpdateUserProfileInformation::class);
                Fortify::updateUserPasswordsUsing(UpdateUserPassword::class);
                Fortify::resetUserPasswordsUsing(ResetUserPassword::class);
    
                /*RateLimiter::for('login', function (Request $request) {
                    return Limit::perMinute(5)->by($request->email.$request->ip());
                });*/
    
                RateLimiter::for('two-factor', function (Request $request) {
                    return Limit::perMinute(5)->by($request->session()->get('login.id'));
                });
            }
        }
    
  5. Наконец, TwoFactorLoginResponse:

            <?php
    
    namespace App\Http\Responses;
    
    use Illuminate\Http\JsonResponse;
    use Laravel\Fortify\Contracts\TwoFactorLoginResponse as TwoFactorLoginResponseContract;
    
    class TwoFactorLoginResponse implements TwoFactorLoginResponseContract
    {
        /**
         * Create an HTTP response that represents the object.
         *
         * @param  \Illuminate\Http\Request  $request
         * @return \Symfony\Component\HttpFoundation\Response
         */
        public function toResponse($request)
        {
            $user = \Auth::user();
    
            $this->storeCookieIfNotInDB($user);
    
            $role = $user->role;
    
            if ($request->wantsJson()) {
                return new JsonResponse('', 204);
            }
    
            if ($role == "0") {
                return redirect()->route('user.home');
            } else {
                return redirect()->route('admin.home');
            }
        }
    
        /**
         * Store the cookie if it is not in the database.
         *
         * @param  \App\Models\User\User  $user
         * @return void
         */
        protected function storeCookieIfNotInDB($user)
        {
            $two_factor_cookies = json_decode($user->two_factor_cookies);
            if (!is_array($two_factor_cookies)){
                $two_factor_cookies = [];
            }
            $two_factor_cookie = \Cookie::get('2fa');
    
            if (!in_array($two_factor_cookie,$two_factor_cookies)) {
                $two_factor_cookie = md5(now());
                $two_factor_cookies[] = $two_factor_cookie;
                if (count($two_factor_cookies) > 3) {
                    array_shift($two_factor_cookies);
                }
    
                $user->two_factor_cookies = json_encode($two_factor_cookies);
                $user->save();
    
                $lifetime = 60 * 24 * 365; //one year
                \Cookie::queue('2fa',$two_factor_cookie,$lifetime);
            }
        }
    }
    

После входа в систему он будет искать файл cookie 2fa. Если его содержимое хранится в базе данных, вводить код повторно не потребуется. Чтобы предотвратить сохранение неограниченного количества файлов cookie в БД, вы можете добавить максимальный лимит (я установил его 3).

Спасибо Maarten Veerman за первоначальную помощь.

Согласно этой строке: https://github.com/laravel/fortify/blob/82c99b6999f7e89f402cfd7eb4074e619382b3b7/src/Http/Controllers/AuthenticatedSessionController.php#L80

вы можете создать pipelines.login запись в вашем файле конфигурации fortify.

Решение было бы:

  • создать запись конфигурации
  • скопируйте настройку конвейера в приведенном выше файле, строка 84.
  • создайте собственный класс, убедитесь, что конфигурация конвейера указывает на ваш новый класс.
  • сделать новый класс расширенным по умолчанию fortify AttemptToAuthenticate класс.
  • перезаписать handle функцию, добавьте свою логику в новую функцию, где вы проверяете cookie на устройстве.
Другие вопросы по тегам