Hashowanie i weryfikacja haseł przez PBKDF2

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

/**
 * Hashowanie i weryfikacja haseł algorytmem PBKDF2 — skryptyJAVA.pl
 * Zapisz jako: HasherHasel.java
 */
public class HasherHasel {

    private static final String ALGORYTM = "PBKDF2WithHmacSHA256";
    private static final String IDENTYFIKATOR = "pbkdf2_sha256";
    private static final int ITERACJE = 600_000;
    private static final int MIN_ITERACJI = 100_000;
    private static final int MAX_ITERACJI = 2_000_000;
    private static final int DLUGOSC_BITOW = 256;
    private static final int BAJTY_SOLI = 16;
    private static final SecureRandom LOSOWE = new SecureRandom();
    private static final Base64.Encoder KODER = Base64.getUrlEncoder().withoutPadding();
    private static final Base64.Decoder DEKODER = Base64.getUrlDecoder();

    /**
     * Tworzy rekord: algorytm$iteracje$sól$skrót. Sól i skrót są zapisane jako Base64 URL-safe.
     * Hasło przekazujemy jako char[], aby kod wywołujący mógł później wyzerować tablicę.
     */
    public static String hashuj(char[] haslo) throws GeneralSecurityException {
        if (haslo == null || haslo.length == 0) {
            throw new IllegalArgumentException("Hasło nie może być puste.");
        }
        byte[] sol = new byte[BAJTY_SOLI];
        LOSOWE.nextBytes(sol);
        byte[] skrot = wyprowadzKlucz(haslo, sol, ITERACJE, DLUGOSC_BITOW);
        try {
            return IDENTYFIKATOR + "$" + ITERACJE + "$"
                    + KODER.encodeToString(sol) + "$" + KODER.encodeToString(skrot);
        } finally {
            Arrays.fill(skrot, (byte) 0);
        }
    }

    /** Zwraca false również dla uszkodzonego lub nieobsługiwanego rekordu z bazy. */
    public static boolean weryfikuj(char[] haslo, String zapis) {
        if (haslo == null || zapis == null) { return false; }
        try {
            String[] czesci = zapis.split("\\$", -1);
            if (czesci.length != 4 || !czesci[0].equals(IDENTYFIKATOR)) { return false; }

            int iteracje = Integer.parseInt(czesci[1]);
            if (iteracje < MIN_ITERACJI || iteracje > MAX_ITERACJI) { return false; }
            byte[] sol = DEKODER.decode(czesci[2]);
            byte[] oczekiwany = DEKODER.decode(czesci[3]);
            if (sol.length < 16 || sol.length > 64
                    || oczekiwany.length < 16 || oczekiwany.length > 64) { return false; }

            byte[] obliczony = wyprowadzKlucz(haslo, sol, iteracje, oczekiwany.length * 8);
            try {
                // Porównanie nie kończy się na pierwszym różnym bajcie, co ogranicza wyciek czasowy.
                return MessageDigest.isEqual(oczekiwany, obliczony);
            } finally {
                Arrays.fill(obliczony, (byte) 0);
            }
        } catch (GeneralSecurityException | IllegalArgumentException blad) {
            return false;
        }
    }

    /** Uruchamia PBKDF2 i czyści wewnętrzną kopię hasła przechowywaną przez PBEKeySpec. */
    private static byte[] wyprowadzKlucz(char[] haslo, byte[] sol, int iteracje, int bity)
            throws GeneralSecurityException {
        PBEKeySpec parametry = new PBEKeySpec(haslo, sol, iteracje, bity);
        try {
            return SecretKeyFactory.getInstance(ALGORYTM).generateSecret(parametry).getEncoded();
        } finally {
            parametry.clearPassword();
        }
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) throws GeneralSecurityException {
        char[] dobreHaslo = "Kawa-i-Java-2026!".toCharArray();
        char[] zleHaslo = "Kawa-i-Java-2025!".toCharArray();
        try {
            String zapis = hashuj(dobreHaslo);
            System.out.println("Rekord do bazy:   " + zapis);
            System.out.println("Poprawne hasło:   " + weryfikuj(dobreHaslo, zapis));
            System.out.println("Błędne hasło:     " + weryfikuj(zleHaslo, zapis));
            System.out.println("Uszkodzony zapis: " + weryfikuj(dobreHaslo, "niepoprawny"));
        } finally {
            // Kod wywołujący odpowiada za wyzerowanie własnych tablic z hasłami.
            Arrays.fill(dobreHaslo, '\0');
            Arrays.fill(zleHaslo, '\0');
        }
    }
}