AES, RSA, DES Encryption Explained: What Actually Matters in Production

package io.thecodeforge.dsa;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * DO NOT USE THIS IN NEW CODE.
 * This class exists solely to MIGRATE data encrypted with legacy 3DES.
 * After migration, delete this class and rotate all keys immediately.
 * Reference: SWEET32 attack (CVE-2016-2183) 64-bit block cipher birthday bound.
 */
public class LegacyDesDecryptor {

    private static final String ALGORITHM = "DESede";
    private static final String TRANSFORMATION = "DESede/CBC/PKCS5Padding";

    public static String decryptForMigration(String encryptedBase64, byte[] rawKey, byte[] iv) throws Exception {
        if (rawKey.length != 24) {
            throw new IllegalArgumentException(
                "3DES key must be 24 bytes. Got: " + rawKey.length +
                ". Ensure your key is correctly padded or sourced."
            );
        }

        DESedeKeySpec keySpec = new DESedeKeySpec(rawKey);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
        SecretKey secretKey = keyFactory.generateSecret(keySpec);

        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        javax.crypto.spec.IvParameterSpec ivSpec = new javax.crypto.spec.IvParameterSpec(iv);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec);

        byte[] cipherBytes = Base64.getDecoder().decode(encryptedBase64);
        byte[] plainBytes = cipher.doFinal(cipherBytes);

        return new String(plainBytes, StandardCharsets.UTF_8);
    }

    public static void main(String[] args) throws Exception {
        byte[] legacyKey = "ThisIsACOMPLETELY24ByteLegacyKey!!".getBytes(StandardCharsets.UTF_8);
        byte[] legacyIv  = "8ByteIV!".getBytes(StandardCharsets.UTF_8);

        DESedeKeySpec keySpec = new DESedeKeySpec(legacyKey);
        SecretKey secretKey = SecretKeyFactory.getInstance("DESede").generateSecret(keySpec);
        Cipher encCipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
        encCipher.init(Cipher.ENCRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(legacyIv));
        byte[] encrypted = encCipher.doFinal("41111111111111112222".getBytes(StandardCharsets.UTF_8));
        String encryptedBase64 = Base64.getEncoder().encodeToString(encrypted);

        System.out.println("Legacy 3DES ciphertext (Base64): " + encryptedBase64);

        String recovered = decryptForMigration(encryptedBase64, legacyKey, legacyIv);
        System.out.println("Recovered plaintext for re-encryption: " + recovered);
        System.out.println("\nNEXT STEP: Pass recovered plaintext to AesGcmEncryptor.encrypt() immediately.");
    }
}

package io.thecodeforge.dsa;

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.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * Production-grade AES-256-GCM encryption for a user PII service.
 * Key Lifecycle: the `encryptionKey` here would typically come from AWS KMS, HashiCorp Vault,
 * or Google Cloud KMS in real production never generated or stored within the same service.
 */
public class AesGcmEncryptor {
    private static final int GCM_TAG_LENGTH_BITS = 128;
    private static final int GCM_NONCE_LENGTH_BYTES = 12;

    private final SecretKey encryptionKey;
    private final SecureRandom secureRandom;

    public AesGcmEncryptor(SecretKey encryptionKey) {
        this.encryptionKey = encryptionKey;
        this.secureRandom = new SecureRandom();
    }

    public String encrypt(String plaintext) throws GeneralSecurityException {
        byte[] nonce = new byte[GCM_NONCE_LENGTH_BYTES];
        secureRandom.nextBytes(nonce);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec parameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH_BITS, nonce);
        cipher.init(Cipher.ENCRYPT_MODE, encryptionKey, parameterSpec);

        byte[] plaintextBytes = plaintext.getBytes(StandardCharsets.UTF_8);
        byte[] ciphertextWithTag = cipher.doFinal(plaintextBytes);

        ByteBuffer byteBuffer = ByteBuffer.allocate(GCM_NONCE_LENGTH_BYTES + ciphertextWithTag.length);
        byteBuffer.put(nonce);
        byteBuffer.put(ciphertextWithTag);

        return Base64.getEncoder().encodeToString(byteBuffer.array());
    }

    public String decrypt(String encryptedBase64) throws GeneralSecurityException {
        byte[] encryptedPayload = Base64.getDecoder().decode(encryptedBase64);

        ByteBuffer byteBuffer = ByteBuffer.wrap(encryptedPayload);
        byte[] nonce = new byte[GCM_NONCE_LENGTH_BYTES];
        byteBuffer.get(nonce);

        byte[] ciphertextWithTag = new byte[byteBuffer.remaining()];
        byteBuffer.get(ciphertextWithTag);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec parameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH_BITS, nonce);
        cipher.init(Cipher.DECRYPT_MODE, encryptionKey, parameterSpec);

        byte[] plaintextBytes = cipher.doFinal(ciphertextWithTag);
        return new String(plaintextBytes, StandardCharsets.UTF_8);
    }

    public static SecretKey generateKey() throws GeneralSecurityException {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256, new SecureRandom());
        return keyGen.generateKey();
    }

    public static void main(String[] args) throws Exception {
        SecretKey key = generateKey();
        AesGcmEncryptor encryptor = new AesGcmEncryptor(key);

        String ssn = "123-45-6789";
        System.out.println("Original SSN:       " + ssn);

        String encryptedSsn = encryptor.encrypt(ssn);
        System.out.println("Encrypted (Base64): " + encryptedSsn);

        String decryptedSsn = encryptor.decrypt(encryptedSsn);
        System.out.println("Decrypted SSN:      " + decryptedSsn);

        System.out.println("\n--- Tamper Detection Demo ---");
        byte[] tamperedBytes = Base64.getDecoder().decode(encryptedSsn);
        tamperedBytes[15] ^= 0xFF;
        String tamperedBase64 = Base64.getEncoder().encodeToString(tamperedBytes);
        try {
            encryptor.decrypt(tamperedBase64);
        } catch (javax.crypto.AEADBadTagException e) {
            System.out.println("Tamper detected AEADBadTagException thrown. This is CORRECT behavior. Alert your security team.");
        }
    }
}

package io.thecodeforge.dsa;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.ChaCha20ParameterSpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * ChaCha20-Poly1305 AEAD encryption the alternative to AES-GCM for platforms without AES-NI.
 * Available in Java 11+ via the standard JCA (Java Cryptography Architecture).
 * Use this for mobile clients, embedded devices, or when targeting ARM without crypto extensions.
 */
public class ChaCha20Poly1305Encryptor {
    private static final int NONCE_LENGTH_BYTES = 12;
    private static final int KEY_LENGTH_BYTES = 32;

    private final SecretKey key;
    private final SecureRandom secureRandom;

    public ChaCha20Poly1305Encryptor(SecretKey key) {
        this.key = key;
        this.secureRandom = new SecureRandom();
    }

    public String encrypt(String plaintext, byte[] associatedData) throws GeneralSecurityException {
        byte[] nonce = new byte[NONCE_LENGTH_BYTES];
        secureRandom.nextBytes(nonce);

        Cipher cipher = Cipher.getInstance("ChaCha20-Poly1305");
        IvParameterSpec nonceSpec = new IvParameterSpec(nonce);
        cipher.init(Cipher.ENCRYPT_MODE, key, nonceSpec);
        if (associatedData != null) {
            cipher.updateAAD(associatedData);
        }

        byte[] ciphertextWithTag = cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8));

        ByteBuffer buffer = ByteBuffer.allocate(NONCE_LENGTH_BYTES + ciphertextWithTag.length);
        buffer.put(nonce);
        buffer.put(ciphertextWithTag);
        return Base64.getEncoder().encodeToString(buffer.array());
    }

    public String decrypt(String encryptedBase64, byte[] associatedData) throws GeneralSecurityException {
        byte[] payload = Base64.getDecoder().decode(encryptedBase64);
        ByteBuffer buffer = ByteBuffer.wrap(payload);

        byte[] nonce = new byte[NONCE_LENGTH_BYTES];
        buffer.get(nonce);
        byte[] ciphertextWithTag = new byte[buffer.remaining()];
        buffer.get(ciphertextWithTag);

        Cipher cipher = Cipher.getInstance("ChaCha20-Poly1305");
        IvParameterSpec nonceSpec = new IvParameterSpec(nonce);
        cipher.init(Cipher.DECRYPT_MODE, key, nonceSpec);
        if (associatedData != null) {
            cipher.updateAAD(associatedData);
        }

        byte[] plaintextBytes = cipher.doFinal(ciphertextWithTag);
        return new String(plaintextBytes, StandardCharsets.UTF_8);
    }

    public static SecretKey generateKey() throws GeneralSecurityException {
        KeyGenerator keyGen = KeyGenerator.getInstance("ChaCha20");
        keyGen.init(256, new SecureRandom());
        return keyGen.generateKey();
    }

    public static void main(String[] args) throws Exception {
        SecretKey key = generateKey();
        ChaCha20Poly1305Encryptor encryptor = new ChaCha20Poly1305Encryptor(key);

        String data = "Confidential medical record";
        byte[] aad = "RecordId:PRNT001".getBytes(StandardCharsets.UTF_8);

        System.out.println("Original:     " + data);
        String encrypted = encryptor.encrypt(data, aad);
        System.out.println("Encrypted:    " + encrypted);

        String decrypted = encryptor.decrypt(encrypted, aad);
        System.out.println("Decrypted:    " + decrypted);

        System.out.println("\n--- AAD Mismatch Demo ---");
        byte[] wrongAad = "RecordId:PRNT002".getBytes(StandardCharsets.UTF_8);
        try {
            encryptor.decrypt(encrypted, wrongAad);
        } catch (GeneralSecurityException e) {
            System.out.println("AAD mismatch detected AEADBadTagException thrown. Correct behavior.");
        }
    }
}

package io.thecodeforge.dsa;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.OAEPParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSource;
import java.util.Base64;

/**
 * Hybrid encryption RSA wraps an ephemeral AES-GCM key; AES-GCM encrypts the payload.
 */
public class HybridEncryptionService {

    private static final int AES_KEY_SIZE_BITS = 256;
    private static final int GCM_TAG_LENGTH_BITS = 128;
    private static final int GCM_NONCE_LENGTH_BYTES = 12;
    private static final int RSA_KEY_SIZE = 2048;

    public static String encrypt(String payload, PublicKey recipientPublicKey) throws GeneralSecurityException {
        KeyGenerator aesKeyGen = KeyGenerator.getInstance("AES");
        aesKeyGen.init(AES_KEY_SIZE_BITS, new SecureRandom());
        SecretKey ephemeralAesKey = aesKeyGen.generateKey();

        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        OAEPParameterSpec oaepParams = new OAEPParameterSpec(
            "SHA-256", "MGF1", MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT
        );
        rsaCipher.init(Cipher.ENCRYPT_MODE, recipientPublicKey, oaepParams);
        byte[] encryptedAesKey = rsaCipher.doFinal(ephemeralAesKey.getEncoded());

        byte[] nonce = new byte[GCM_NONCE_LENGTH_BYTES];
        new SecureRandom().nextBytes(nonce);

        Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding");
        aesCipher.init(Cipher.ENCRYPT_MODE, ephemeralAesKey, new GCMParameterSpec(GCM_TAG_LENGTH_BITS, nonce));
        byte[] aesCiphertext = aesCipher.doFinal(payload.getBytes(StandardCharsets.UTF_8));

        int keyLen = encryptedAesKey.length;
        ByteBuffer buffer = ByteBuffer.allocate(4 + keyLen + GCM_NONCE_LENGTH_BYTES + aesCiphertext.length);
        buffer.putInt(keyLen);
        buffer.put(encryptedAesKey);
        buffer.put(nonce);
        buffer.put(aesCiphertext);

        return Base64.getEncoder().encodeToString(buffer.array());
    }

    public static String decrypt(String hybridCiphertextBase64, PrivateKey recipientPrivateKey) throws GeneralSecurityException {
        byte[] payload = Base64.getDecoder().decode(hybridCiphertextBase64);
        ByteBuffer buffer = ByteBuffer.wrap(payload);

        int keyLen = buffer.getInt();
        if (keyLen < 0 || keyLen > payload.length - 4 - GCM_NONCE_LENGTH_BYTES) {
            throw new GeneralSecurityException("Invalid wrapped key length in payload.");
        }
        byte[] encryptedAesKey = new byte[keyLen];
        buffer.get(encryptedAesKey);

        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        OAEPParameterSpec oaepParams = new OAEPParameterSpec(
            "SHA-256", "MGF1", MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT
        );
        rsaCipher.init(Cipher.DECRYPT_MODE, recipientPrivateKey, oaepParams);
        byte[] aesKeyBytes = rsaCipher.doFinal(encryptedAesKey);
        SecretKey ephemeralAesKey = new SecretKeySpec(aesKeyBytes, "AES");

        byte[] nonce = new byte[GCM_NONCE_LENGTH_BYTES];
        buffer.get(nonce);
        byte[] aesCiphertext = new byte[buffer.remaining()];
        buffer.get(aesCiphertext);

        Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding");
        aesCipher.init(Cipher.DECRYPT_MODE, ephemeralAesKey, new GCMParameterSpec(GCM_TAG_LENGTH_BITS, nonce));
        byte[] plaintextBytes = aesCipher.doFinal(aesCiphertext);

        return new String(plaintextBytes, StandardCharsets.UTF_8);
    }

    private static KeyPair generateRsaKeyPair(int keySize) throws GeneralSecurityException {
        KeyPairGenerator rsaGen = KeyPairGenerator.getInstance("RSA");
        rsaGen.initialize(keySize, new SecureRandom());
        return rsaGen.generateKeyPair();
    }

    public static void main(String[] args) throws Exception {
        KeyPair keyPair = generateRsaKeyPair(RSA_KEY_SIZE);

        String sensitiveDocument = "{\"patientId\":\"P-9921\",\"diagnosis\":\"T2 Diabetes\",\"notes\":\"Prescribed metformin 500mg\"}";

        System.out.println("Original document:  " + sensitiveDocument);

        String encrypted = encrypt(sensitiveDocument, keyPair.getPublic());
        System.out.println("Encrypted (Base64): " + encrypted.substring(0, 60) + "... [truncated]");

        String decrypted = decrypt(encrypted, keyPair.getPrivate());
        System.out.println("Decrypted document: " + decrypted);
    }
}

package io.thecodeforge.dsa;

import javax.crypto.KeyAgreement;
import java.security.*;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * ECDH key agreement with P-256. Returns a shared secret for symmetric encryption.
 */
public class EcdhKeyAgreement {

    public static KeyPair generateKeyPair() throws GeneralSecurityException {
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
        ECGenParameterSpec ecSpec = new ECGenParameterSpec("secp256r1");
        kpg.initialize(ecSpec, new SecureRandom());
        return kpg.generateKeyPair();
    }

    public static byte[] agree(PrivateKey privateKey, PublicKey otherPublicKey) throws GeneralSecurityException {
        KeyAgreement ka = KeyAgreement.getInstance("ECDH");
        ka.init(privateKey);
        ka.doPhase(otherPublicKey, true);
        return ka.generateSecret();
    }

    public static void main(String[] args) throws Exception {
        KeyPair alice = generateKeyPair();
        KeyPair bob = generateKeyPair();

        byte[] aliceShared = agree(alice.getPrivate(), bob.getPublic());
        byte[] bobShared = agree(bob.getPrivate(), alice.getPublic());

        boolean match = MessageDigest.isEqual(aliceShared, bobShared);
        System.out.println("Shared secrets match: " + match);
        System.out.println("Shared secret (Base64): " + Base64.getEncoder().encodeToString(aliceShared));

        // Next step: derive AES key via HKDF (not shown for brevity)
    }
}

package io.thecodeforge.dsa;

// Note: This example uses placeholder Bouncy Castle PQC APIs (not final).
// In production, use a library like OpenJDK's experimental PQC or OQS provider.

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import java.nio.ByteBuffer;
import java.security.*;
import java.util.Base64;

/**
 * Hybrid encryption: RSA-wrapped AES key + ML-KEM-wrapped AES key.
 * Decryptor tries RSA first, then ML-KEM, to support gradual migration.
 */
public class HybridPqcEncryptor {

    static { Security.addProvider(new BouncyCastleProvider()); }

    public static String encrypt(String plaintext, PublicKey rsaPublicKey, PublicKey mlkemPublicKey) throws Exception {
        // Generate ephemeral AES key
        KeyGenerator aesGen = KeyGenerator.getInstance("AES");
        aesGen.init(256, new SecureRandom());
        SecretKey aesKey = aesGen.generateKey();

        // Wrap AES key with RSA (OAEP)
        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        rsaCipher.init(Cipher.WRAP_MODE, rsaPublicKey);
        byte[] rsaWrapped = rsaCipher.wrap(aesKey);

        // Wrap AES key with ML-KEM (simplified - actual API varies)
        Cipher mlkemCipher = Cipher.getInstance("ML-KEM");
        mlkemCipher.init(Cipher.WRAP_MODE, mlkemPublicKey);
        byte[] mlkemWrapped = mlkemCipher.wrap(aesKey);

        // Encrypt payload with AES-GCM
        byte[] nonce = new byte[12];
        new SecureRandom().nextBytes(nonce);
        Cipher aesGcm = Cipher.getInstance("AES/GCM/NoPadding");
        aesGcm.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(128, nonce));
        byte[] ciphertext = aesGcm.doFinal(plaintext.getBytes());

        // Package: rsaWrappedLen, rsaWrapped, mlkemWrappedLen, mlkemWrapped, nonce, ciphertext
        ByteBuffer buf = ByteBuffer.allocate(4 + rsaWrapped.length + 4 + mlkemWrapped.length + 12 + ciphertext.length);
        buf.putInt(rsaWrapped.length);
        buf.put(rsaWrapped);
        buf.putInt(mlkemWrapped.length);
        buf.put(mlkemWrapped);
        buf.put(nonce);
        buf.put(ciphertext);
        return Base64.getEncoder().encodeToString(buf.array());
    }

    // Decryption mimics: try RSA unwrap, fallback to ML-KEM
    public static String decrypt(String encryptedBase64, PrivateKey rsaPrivateKey, PrivateKey mlkemPrivateKey) throws Exception {
        byte[] data = Base64.getDecoder().decode(encryptedBase64);
        ByteBuffer buf = ByteBuffer.wrap(data);

        int rsaLen = buf.getInt();
        byte[] rsaWrapped = new byte[rsaLen];
        buf.get(rsaWrapped);

        int mlkemLen = buf.getInt();
        byte[] mlkemWrapped = new byte[mlkemLen];
        buf.get(mlkemWrapped);

        byte[] nonce = new byte[12];
        buf.get(nonce);
        byte[] ciphertext = new byte[buf.remaining()];
        buf.get(ciphertext);

        SecretKey aesKey = null;
        // Try RSA first
        try {
            Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
            rsaCipher.init(Cipher.UNWRAP_MODE, rsaPrivateKey);
            aesKey = (SecretKey) rsaCipher.unwrap(rsaWrapped, "AES", Cipher.SECRET_KEY);
        } catch (Exception e) {
            // RSA failed, fallback to ML-KEM
            Cipher mlkemCipher = Cipher.getInstance("ML-KEM");
            mlkemCipher.init(Cipher.UNWRAP_MODE, mlkemPrivateKey);
            aesKey = (SecretKey) mlkemCipher.unwrap(mlkemWrapped, "AES", Cipher.SECRET_KEY);
        }

        Cipher aesGcm = Cipher.getInstance("AES/GCM/NoPadding");
        aesGcm.init(Cipher.DECRYPT_MODE, aesKey, new GCMParameterSpec(128, nonce));
        byte[] plaintext = aesGcm.doFinal(ciphertext);
        return new String(plaintext);
    }
}

// io.thecodeforge — dsa tutorial

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import java.security.SecureRandom;

public class CiphertextOverheadCalculator {
    public static void main(String[] args) throws Exception {
        byte[] plaintext = new byte[10]; // simulate a 10-byte credit card PAN
        SecureRandom random = new SecureRandom();
        random.nextBytes(plaintext);

        // AES-256-GCM: 12-byte IV, 16-byte tag overhead
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        SecretKey key = keyGen.generateKey();

        byte[] iv = new byte[12];
        random.nextBytes(iv);
        GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); // 128-bit tag

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, key, gcmSpec);
        byte[] ciphertext = cipher.doFinal(plaintext);

        System.out.println("Plaintext length: " + plaintext.length + " bytes");
        System.out.println("Ciphertext length: " + ciphertext.length + " bytes");
        System.out.println("Overhead: " + (ciphertext.length - plaintext.length) + " bytes");
    }
}

// io.thecodeforge — dsa tutorial

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;
import java.util.Arrays;

public class ConstantTimeMacVerification {
    public static void main(String[] args) throws Exception {
        // Simulate computing and verifying a HMAC-SHA256 tag
        byte[] keyMaterial = new byte[32];
        new java.security.SecureRandom().nextBytes(keyMaterial);
        SecretKeySpec hmacKey = new SecretKeySpec(keyMaterial, "HmacSHA256");

        String message = "Encrypt then MAC. Always.";
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(hmacKey);
        byte[] computedTag = mac.doFinal(message.getBytes());

        // Attacker provides this tag
        byte[] attackerSuppliedTag = computedTag.clone();
        attackerSuppliedTag[0] ^= 0x01; // flip one bit to simulate forged tag

        // Constant-time comparison — never use Arrays.equals() here
        boolean isValid = MessageDigest.isEqual(computedTag, attackerSuppliedTag);
        System.out.println("Tag valid? " + isValid);
    }
}

// io.thecodeforge — dsa tutorial

import javax.crypto.*;
import java.security.*;

public class EnvelopeEncryptionExample {
    public static void main(String[] args) throws Exception {
        // Simulate envelope encryption with a KEK and DEK
        KeyGenerator kekGen = KeyGenerator.getInstance("AES");
        kekGen.init(256);
        SecretKey kek = kekGen.generateKey();  // stored in HSM

        KeyGenerator dekGen = KeyGenerator.getInstance("AES");
        dekGen.init(256);
        SecretKey dek = dekGen.generateKey();  // per-object key

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, dek);
        byte[] ciphertext = cipher.doFinal("Hello World".getBytes());

        Cipher kekCipher = Cipher.getInstance("AES/GCM/NoPadding");
        kekCipher.init(Cipher.WRAP_MODE, kek);
        byte[] wrappedKey = kekCipher.wrap(dek);

        System.out.println("Ciphertext length: " + ciphertext.length);
        System.out.println("Wrapped DEK length: " + wrappedKey.length);
    }
}

// io.thecodeforge — dsa tutorial

import java.security.*;

public class CodeSigningExample {
    public static void main(String[] args) throws Exception {
        KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");
        gen.initialize(2048);
        KeyPair pair = gen.generateKeyPair();

        byte[] artifact = "v1.2.3-release.apk".getBytes();
        Signature signer = Signature.getInstance("SHA256withRSA");
        signer.initSign(pair.getPrivate());
        signer.update(artifact);
        byte[] signature = signer.sign();

        Signature verifier = Signature.getInstance("SHA256withRSA");
        verifier.initVerify(pair.getPublic());
        verifier.update(artifact);
        boolean valid = verifier.verify(signature);

        System.out.println("Signature valid: " + valid);
        System.out.println("Signature size: " + signature.length + " bytes");
    }
}

// io.thecodeforge — dsa tutorial
import java.security.*;

public class DSASignVerify {
    public static void main(String[] args) throws Exception {
        KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");
        gen.initialize(2048);
        KeyPair pair = gen.generateKeyPair();

        Signature sig = Signature.getInstance("SHA256withDSA");
        sig.initSign(pair.getPrivate());
        sig.update("message".getBytes());
        byte[] signature = sig.sign();

        sig.initVerify(pair.getPublic());
        sig.update("message".getBytes());
        System.out.println(sig.verify(signature)); // true
    }
}

// io.thecodeforge — dsa tutorial
import java.math.BigInteger;

public class DSASteps {
    public static void main(String[] args) {
        BigInteger p = new BigInteger("898846567431157953864652595394512366808988489471153286367150405788663379027504815663542386612037680105600569399356966788293948844072083112464237195137569542245315795733958765167787106602363113136321393606421057822318848916587346997175181835116606291843589786854775390654520057727415504822862223893807866197468521"); // 1024-bit
        BigInteger q = new BigInteger("1361129467683753853853498429727072845823"); // 160-bit
        BigInteger g = new BigInteger("12345"); // simplified
        BigInteger x = new BigInteger("98765"); // private key
        BigInteger y = g.modPow(x, p); // public key
        System.out.println("y bits: " + y.bitLength());
    }
}

// io.thecodeforge — dsa tutorial
import java.security.*;

public class SignatureSizeCompare {
    public static void main(String[] args) throws Exception {
        KeyPairGenerator rsaGen = KeyPairGenerator.getInstance("RSA");
        rsaGen.initialize(3072);
        KeyPair rsa = rsaGen.generateKeyPair();

        Signature rsaSig = Signature.getInstance("SHA256withRSA");
        rsaSig.initSign(rsa.getPrivate());
        rsaSig.update("data".getBytes());
        byte[] rsaSign = rsaSig.sign();
        System.out.println("RSA sig: " + rsaSign.length + " bytes");

        KeyPairGenerator dsaGen = KeyPairGenerator.getInstance("DSA");
        dsaGen.initialize(2048);
        KeyPair dsa = dsaGen.generateKeyPair();

        Signature dsaSig = Signature.getInstance("SHA256withDSA");
        dsaSig.initSign(dsa.getPrivate());
        dsaSig.update("data".getBytes());
        byte[] dsaSign = dsaSig.sign();
        System.out.println("DSA sig: " + dsaSign.length + " bytes");
    }
}

// io.thecodeforge — dsa tutorial
import java.security.*;
public class TerminologyExample {
    public static void main(String[] args) throws Exception {
        // Generate DSA key pair
        KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");
        gen.initialize(1024);
        KeyPair pair = gen.generateKeyPair();
        PrivateKey priv = pair.getPrivate();
        PublicKey pub = pair.getPublic();
        // Hash the message
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest("Hello".getBytes());
        System.out.println("Hash: " + bytesToHex(hash));
        System.out.println("Public key exponent: " + pub.getFormat());
    }
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) sb.append(String.format("%02x", b));
        return sb.toString();
    }
}

// io.thecodeforge — dsa tutorial
import java.security.*;
public class DSAAdvantage {
    public static void main(String[] args) throws Exception {
        Signature sig = Signature.getInstance("SHA256withDSA");
        KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");
        gen.initialize(1024);
        KeyPair pair = gen.generateKeyPair();
        // Sign
        sig.initSign(pair.getPrivate());
        sig.update("Test message".getBytes());
        byte[] signature = sig.sign();
        System.out.println("Signature length: " + signature.length + " bytes");
        // Verify
        sig.initVerify(pair.getPublic());
        sig.update("Test message".getBytes());
        System.out.println("Verification: " + sig.verify(signature));
    }
}

// io.thecodeforge — dsa tutorial
import java.security.*;
public class DSADrawback {
    public static void main(String[] args) throws Exception {
        // Measure verification speed
        KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA");
        gen.initialize(1024);
        KeyPair pair = gen.generateKeyPair();
        Signature sig = Signature.getInstance("SHA256withDSA");
        sig.initSign(pair.getPrivate());
        sig.update("Hello".getBytes());
        byte[] sign = sig.sign();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            sig.initVerify(pair.getPublic());
            sig.update("Hello".getBytes());
            sig.verify(sign);
        }
        long end = System.nanoTime();
        System.out.println("Time per verify: " + (end - start)/1000 + " ns");
    }
}