> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Hashing

> Leer hoe je wachtwoorden veilig hasht en verifieert met de Hash-facade van Laravel. Behandelt de configuratie en het gebruik van de bcrypt- en Argon2-algoritmen.

## Wat is hashing

Hashing is het proces waarbij platte tekst, zoals wachtwoorden, via een eenrichtingstransformatie wordt omgezet in een string met vaste lengte.
Dezelfde invoer levert altijd dezelfde hash op, maar je kunt de oorspronkelijke platte tekst niet uit de hash herleiden.

De `Hash`-facade van Laravel ondersteunt de hashalgoritmen **bcrypt** en **Argon2** voor het veilig opslaan van wachtwoorden.

### Vergelijking van algoritmen

| Algoritme    | Kenmerken                                                                         | Aanbevolen gebruik                           |
| ------------ | --------------------------------------------------------------------------------- | -------------------------------------------- |
| **bcrypt**   | Rekenkosten instelbaar via de workfactor (rounds). Standaard                      | Algemene webapplicaties                      |
| **argon2i**  | Geheugen, tijd en aantal threads instelbaar. Bestand tegen side-channel-aanvallen | Situaties waarin hoge beveiliging vereist is |
| **argon2id** | Hybride van argon2i en argon2d. Aanbevolen door PHC                               | Nieuwe projecten die Argon2 gebruiken        |

<Info>
  De "workfactor" van bcrypt bepaalt hoelang het genereren van een hash duurt. Hoe trager de hash, hoe beter de weerstand tegen brute-force-aanvallen. Door de workfactor te verhogen naarmate hardware sneller wordt, houd je de beveiliging op peil.
</Info>

### Flow van hashen en verifiëren

```mermaid theme={null}
flowchart LR
    A[Wachtwoord in platte tekst] -->|Hash::make| B["Hashwaarde<br>opgeslagen in DB"]
    C[Invoer bij inloggen] -->|Hash::check| D{Match?}
    B --> D
    D -->|true| E[Authenticatie geslaagd]
    D -->|false| F[Authenticatie mislukt]
```

***

## Configuratie

Standaard gebruikt Laravel de `bcrypt`-driver. Je kunt dit wijzigen met de omgevingsvariabele `HASH_DRIVER`.

```ini theme={null}
# .env
HASH_DRIVER=bcrypt  # bcrypt / argon / argon2id
```

Wil je de hashconfiguratie aanpassen, publiceer dan het configuratiebestand met `config:publish`.

```shell theme={null}
php artisan config:publish hashing
```

Na het publiceren kun je in `config/hashing.php` onder andere de standaard workfactor wijzigen.

***

## Basisgebruik

### Een wachtwoord hashen

Geef de platte tekst van het wachtwoord door aan `Hash::make()` en je krijgt de hashwaarde terug. Deze hashwaarde sla je op in de database.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;

class PasswordController extends Controller
{
    public function update(Request $request): RedirectResponse
    {
        $request->validate([
            'password' => ['required', 'min:8', 'confirmed'],
        ]);

        $request->user()->fill([
            'password' => Hash::make($request->password),
        ])->save();

        return redirect('/profile');
    }
}
```

<Warning>
  Sla de hashwaarde op in de database, maar sla nooit het wachtwoord in platte tekst op.
</Warning>

### De bcrypt-workfactor aanpassen

Met de optie `rounds` pas je de rekenkosten van het hashen aan. Hoe hoger de waarde, hoe veiliger, maar ook hoe langer de verwerking duurt.
De standaardwaarde (12) is geschikt voor de meeste applicaties.

```php theme={null}
$hashed = Hash::make('plain-text-password', [
    'rounds' => 14,
]);
```

### De Argon2-workfactor aanpassen

Gebruik je Argon2, dan kun je de rekenkosten aanpassen met de opties `memory`, `time` en `threads`.

```php theme={null}
$hashed = Hash::make('plain-text-password', [
    'memory'  => 65536, // in KiB
    'time'    => 4,
    'threads' => 2,
]);
```

| Optie     | Beschrijving                        | Standaard |
| --------- | ----------------------------------- | --------- |
| `memory`  | Hoeveelheid gebruikt geheugen (KiB) | 65536     |
| `time`    | Aantal iteraties                    | 4         |
| `threads` | Aantal gebruikte threads            | 1         |

<Tip>
  Zie de [officiële PHP-documentatie](https://secure.php.net/manual/ja/function.password-hash.php) voor meer informatie over de Argon2-opties.
</Tip>

***

## Wachtwoorden verifiëren

Met `Hash::check()` controleer je of een wachtwoord in platte tekst overeenkomt met de opgeslagen hash.
Een typisch voorbeeld binnen een inlogproces:

```php theme={null}
use Illuminate\Support\Facades\Hash;

if (Hash::check($request->password, $user->password)) {
    // Wachtwoord komt overeen
} else {
    // Wachtwoord komt niet overeen
}
```

Gebruik je `Auth::attempt()`, dan gebeurt deze controle automatisch en hoef je hem niet zelf aan te roepen.
`Hash::check()` is vooral handig wanneer je handmatig het huidige wachtwoord wilt controleren.

```php theme={null}
// Voorbeeld: het huidige wachtwoord controleren in een wachtwoord-wijzigformulier
if (! Hash::check($request->current_password, $request->user()->password)) {
    return back()->withErrors(['current_password' => 'Het huidige wachtwoord is onjuist.']);
}
```

***

## Bepalen of rehashen nodig is

Met `Hash::needsRehash()` controleer je of de workfactor waarmee de hash is gegenereerd afwijkt van de huidige configuratie.
Dit gebruik je om bestaande hashes bij te werken met de nieuwe instellingen nadat je de workfactor hebt gewijzigd.

```php theme={null}
use Illuminate\Support\Facades\Hash;

if (Hash::needsRehash($user->password)) {
    $user->update([
        'password' => Hash::make($plainTextPassword),
    ]);
}
```

Een voorbeeld waarbij je rehasht na een geslaagde login:

```mermaid theme={null}
flowchart TD
    A[Login geslaagd] --> B{needsRehash?}
    B -->|true| C[Opnieuw hashen met nieuwe<br>workfactor en opslaan]
    B -->|false| D[Gewoon doorgaan]
    C --> D
```

```php theme={null}
// Rehashen binnen het inlogproces
if (Auth::attempt($credentials)) {
    if (Hash::needsRehash(Auth::user()->password)) {
        Auth::user()->update([
            'password' => Hash::make($credentials['password']),
        ]);
    }

    return redirect()->intended('/dashboard');
}
```

<Tip>
  Herzie de workfactor regelmatig naarmate hardware sneller wordt, zodat de beveiliging op peil blijft. Door `needsRehash()` te gebruiken kun je wachtwoorden op een natuurlijk moment bijwerken: wanneer de gebruiker inlogt.
</Tip>

***

## Verificatie van het hashalgoritme

Standaard verifieert `Hash::check()` of de hash is gegenereerd met het momenteel geconfigureerde algoritme.
Wijkt het algoritme af, dan wordt een `RuntimeException` gegooid.

Dit voorkomt aanvallen via manipulatie van het hashalgoritme.

Moet je meerdere algoritmen tegelijk ondersteunen, bijvoorbeeld tijdens een migratie naar een ander algoritme, dan kun je deze verificatie uitschakelen door `HASH_VERIFY` op `false` te zetten.

```ini theme={null}
# .env
HASH_VERIFY=false
```

<Warning>
  Met `HASH_VERIFY=false` is de algoritmeverificatie uitgeschakeld. Gebruik dit alleen tijdens de migratieperiode en zet het na afronding weer terug naar `true` (de standaard).
</Warning>

***

## Samenvatting

| Wat je wilt doen                  | Hoe                              |
| --------------------------------- | -------------------------------- |
| Een wachtwoord hashen             | `Hash::make($password)`          |
| Een hash verifiëren               | `Hash::check($plain, $hash)`     |
| Controleren of rehashen nodig is  | `Hash::needsRehash($hash)`       |
| De hashdriver wijzigen            | Omgevingsvariabele `HASH_DRIVER` |
| Algoritmeverificatie uitschakelen | `HASH_VERIFY=false`              |

## Volgende stappen

<Card title="Introductie tot authenticatie" icon="lock" href="/nl/authentication">
  Leer het volledige plaatje van authenticatie, waaronder het implementeren van een inlogproces met `Hash::check()`.
</Card>


## Related topics

- [Versleuteling (Encryption)](/nl/encryption.md)
- [Laravel Fortify en de starter kits](/nl/advanced/fortify.md)
- [Upgraden van Laravel 10 naar 11](/nl/blog/upgrade-10-to-11.md)
- [Contracts](/nl/contracts.md)
- [Facades](/nl/facades.md)