Szyfrowanie i odszyfrowanie przez AES-GCM

import javax.crypto.AEADBadTagException;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

/**
 * Uwierzytelnione szyfrowanie tekstu algorytmem AES-GCM — skryptyJAVA.pl
 * Zapisz jako: SzyfrowanieAesGcm.java
 */
public class SzyfrowanieAesGcm {

    private static final String TRANSFORMACJA = "AES/GCM/NoPadding";
    private static final String WERSJA = "AESGCM1";
    private static final int BAJTY_IV = 12;
    private static final int BITY_TAGU = 128;
    private static final SecureRandom LOSOWE = new SecureRandom();
    private static final Base64.Encoder KODER = Base64.getUrlEncoder().withoutPadding();
    private static final Base64.Decoder DEKODER = Base64.getUrlDecoder();

    /** Generuje nowy 256-bitowy klucz AES. Klucza nie wolno trzymać obok szyfrogramu. */
    public static SecretKey generujKlucz() throws GeneralSecurityException {
        KeyGenerator generator = KeyGenerator.getInstance("AES");
        generator.init(256, LOSOWE);
        return generator.generateKey();
    }

    /** Eksportuje klucz do Base64 URL-safe, np. do chronionego magazynu sekretów. */
    public static String zapiszKlucz(SecretKey klucz) {
        return KODER.encodeToString(klucz.getEncoded());
    }

    /** Odtwarza klucz 128-, 192- albo 256-bitowy z zapisu Base64 URL-safe. */
    public static SecretKey wczytajKlucz(String zapis) {
        byte[] bajty = DEKODER.decode(zapis);
        try {
            if (bajty.length != 16 && bajty.length != 24 && bajty.length != 32) {
                throw new IllegalArgumentException("Nieprawidłowa długość klucza AES.");
            }
            return new SecretKeySpec(bajty, "AES");
        } finally {
            Arrays.fill(bajty, (byte) 0);
        }
    }

    /** Zwraca zapis WERSJA.IV.SZYFROGRAM; 16-bajtowy tag GCM jest częścią szyfrogramu. */
    public static String szyfruj(String tekst, SecretKey klucz, byte[] aad)
            throws GeneralSecurityException {
        byte[] iv = new byte[BAJTY_IV];
        LOSOWE.nextBytes(iv);
        Cipher szyfr = Cipher.getInstance(TRANSFORMACJA);
        szyfr.init(Cipher.ENCRYPT_MODE, klucz, new GCMParameterSpec(BITY_TAGU, iv));
        if (aad != null && aad.length > 0) { szyfr.updateAAD(aad); }
        byte[] szyfrogram = szyfr.doFinal(tekst.getBytes(StandardCharsets.UTF_8));
        return WERSJA + "." + KODER.encodeToString(iv) + "." + KODER.encodeToString(szyfrogram);
    }

    /**
     * Odszyfrowuje i weryfikuje tag. Zły klucz, inne AAD albo zmieniony bajt danych kończą się
     * wyjątkiem AEADBadTagException, a brakujący lub uszkodzony zapis — IllegalArgumentException.
     */
    public static String odszyfruj(String zapis, SecretKey klucz, byte[] aad)
            throws GeneralSecurityException {
        if (zapis == null) {
            throw new IllegalArgumentException("Brak zapisu do odszyfrowania.");
        }
        String[] czesci = zapis.split("\\.", -1);
        if (czesci.length != 3 || !czesci[0].equals(WERSJA)) {
            throw new IllegalArgumentException("Nieobsługiwany format szyfrogramu.");
        }
        byte[] iv = DEKODER.decode(czesci[1]);
        byte[] szyfrogram = DEKODER.decode(czesci[2]);
        if (iv.length != BAJTY_IV || szyfrogram.length < BITY_TAGU / 8) {
            throw new IllegalArgumentException("Uszkodzony szyfrogram.");
        }

        Cipher szyfr = Cipher.getInstance(TRANSFORMACJA);
        szyfr.init(Cipher.DECRYPT_MODE, klucz, new GCMParameterSpec(BITY_TAGU, iv));
        if (aad != null && aad.length > 0) { szyfr.updateAAD(aad); }
        byte[] tekst = szyfr.doFinal(szyfrogram);
        return new String(tekst, StandardCharsets.UTF_8);
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) throws GeneralSecurityException {
        SecretKey klucz = generujKlucz();
        String zapisKlucza = zapiszKlucz(klucz);
        SecretKey odtworzonyKlucz = wczytajKlucz(zapisKlucza);
        byte[] aad = "uzytkownik:42".getBytes(StandardCharsets.UTF_8);

        String szyfrogram = szyfruj("Poufna wiadomość: ąęść", odtworzonyKlucz, aad);
        System.out.println("Szyfrogram: " + szyfrogram);
        System.out.println("Odszyfrowano: " + odszyfruj(szyfrogram, odtworzonyKlucz, aad));
        System.out.println("Klucz Base64 ma " + zapisKlucza.length() + " znaki.");

        try {
            byte[] zleAad = "uzytkownik:43".getBytes(StandardCharsets.UTF_8);
            odszyfruj(szyfrogram, odtworzonyKlucz, zleAad);
        } catch (AEADBadTagException blad) {
            System.out.println("Zmienione AAD zostało wykryte — tag GCM jest niepoprawny.");
        }
    }
}