How To Add A Password Hash With Mysql Inquery

Version

Hashing

Introduction
Configuration
Bones Usage
- Hashing Passwords
- Verifying That A Password Matches A Hash
- Determining If A Password Needs To Exist Rehashed

Introduction

The Laravel Hash facade provides secure Bcrypt and Argon2 hashing for storing user passwords. If y'all are using one of the Laravel application starter kits, Bcrypt will be used for registration and hallmark by default.

Bcrypt is a great pick for hashing passwords because its "work factor" is adjustable, which means that the fourth dimension it takes to generate a hash can be increased as hardware power increases. When hashing passwords, wearisome is adept. The longer an algorithm takes to hash a password, the longer it takes malicious users to generate "rainbow tables" of all possible string hash values that may exist used in brute force attacks against applications.

Configuration

The default hashing driver for your awarding is configured in your awarding's config/hashing.php configuration file. There are currently several supported drivers: Bcrypt and Argon2 (Argon2i and Argon2id variants).

Bones Usage

Hashing Passwords

Y'all may hash a password by calling the make method on the Hash facade:

                                                        <?php              
                              namespace                                  App\Http\Controllers;              
                              use                                  App\Http\Controllers\                Controller                ;              
                              use                                  Illuminate\Http\                Request                ;              
                              use                                  Illuminate\Support\Facades\                Hash                ;              
                              class                                                PasswordController                                                extends                                                Controller              
                              {              
                                                              /**              
                                                * Update the password for the user.              
                                                *              
                                                *                                @param                                                \                Illuminate                \                Http                \                Asking                                  $asking              
                                                *                                @return                                                \                Illuminate                \                Http                \                Response              
                                                              */              
                                                              public                                                part                                                update                (                Request                                                $request                )              
                                                {              
                                                              //                                  Validate the new password length...              
                                                              $request                ->                user                ()                ->                fill up                ([              
                                                              '                countersign                '                                                =>                                                Hash                ::                brand                (                $asking                ->newPassword                )              
                                                ])                ->                save                ();              
                                                }              
                              }

Adjusting The Bcrypt Piece of work Factor

If you are using the Bcrypt algorithm, the brand method allows you to manage the work factor of the algorithm using the rounds option; even so, the default work factor managed by Laravel is acceptable for most applications:

                                                        $hashed                                                =                                                Hash                ::                make                (                '                password                '                , [              
                                                              '                rounds                '                                                =>                                                12                ,              
                              ]);

Adjusting The Argon2 Work Factor

If yous are using the Argon2 algorithm, the brand method allows you to manage the work factor of the algorithm using the memory, time, and threads options; however, the default values managed by Laravel are acceptable for nigh applications:

                                                        $hashed                                                =                                                Hash                ::                brand                (                '                password                '                , [              
                                                              '                memory                '                                                =>                                                1024                ,              
                                                              '                time                '                                                =>                                                2                ,              
                                                              '                threads                '                                                =>                                                ii                ,              
                              ]);

{tip} For more information on these options, please refer to the official PHP documentation regarding Argon hashing.

Verifying That A Password Matches A Hash

The check method provided by the Hash facade allows y'all to verify that a given plain-text string corresponds to a given hash:

                                                        if                                  (                Hash                ::                check                (                '                plain-text                '                ,                                $hashedPassword                )) {              
                                                              //                                  The passwords match...              
                              }

Determining If A Countersign Needs To Be Rehashed

The needsRehash method provided past the Hash facade allows y'all to decide if the work factor used past the hasher has changed since the password was hashed. Some applications choose to perform this bank check during the awarding'south authentication process:

                                                        if                                  (                Hash                ::                needsRehash                (                $hashed                )) {              
                                                              $hashed                                                =                                                Hash                ::                make                (                '                plainly-text                '                );              
                              }