Workflow A: Encrypt & Decrypt

Encrypt a message with ML-KEM-768 + AES-256-GCM, then decrypt it.

Workflow B: Sign & Verify

Sign a message with ML-DSA-65, then verify the signature. Try tampering to see verification fail.

Workflow C: Send + Receive Secure Email (Full S/MIME)

Complete end-to-end workflow: sign with ML-DSA-65, encrypt with ML-KEM-768 encapsulation, then decrypt and verify on the recipient side.

import com.qudo.crypto.QudoCrypto;
import com.qudo.crypto.QudoKeyPair;
import com.qudo.crypto.QudoKemResult;
import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;
import java.security.SecureRandom;

// ============================================================
// Initialize the Qudo provider once at application startup
// ============================================================
QudoCrypto provider = QudoCrypto.create();

// ============================================================
// 1. KEY GENERATION — generate ML-KEM and ML-DSA keypairs
// ============================================================
// Recipient generates an ML-KEM-768 keypair (store privKey securely, publish pubKey)
try (QudoKeyPair recipientKeys = provider.generateKeyPair("ML-KEM-768")) {
    byte[] recipientPubKey = recipientKeys.getPublicKeyPem();
    byte[] recipientPrivKey = recipientKeys.getPrivateKeyPem();

    // Sender generates an ML-DSA-65 signing keypair
    try (QudoKeyPair senderKeys = provider.generateKeyPair("ML-DSA-65")) {

        byte[] message = "Q4 revenue exceeded projections by 15%".getBytes();

        // ============================================================
        // 2. SIGN — sender signs the message with ML-DSA-65
        // ============================================================
        byte[] signature = provider.sign(message, senderKeys.getPrivateKeyPem(), "ML-DSA-65");

        // ============================================================
        // 3. ENCRYPT — sender encapsulates + encrypts for recipient
        // ============================================================
        // ML-KEM encapsulate: produces a per-message shared secret
        QudoKemResult encap = provider.kemEncapsulate(recipientPubKey, "ML-KEM-768");
        byte[] kemCiphertext = encap.getCiphertext();   // send this to recipient
        byte[] sharedSecret = encap.getSharedSecret();   // use locally for AES key
        encap.destroy(); // zero shared secret from KEM result

        // Derive AES-256 key from shared secret, then zero the secret
        byte[] aesKey = MessageDigest.getInstance("SHA-256").digest(sharedSecret);
        java.util.Arrays.fill(sharedSecret, (byte) 0);

        // Encrypt with AES-256-GCM
        byte[] iv = new byte[12];
        new SecureRandom().nextBytes(iv);
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(aesKey, "AES"),
                     new GCMParameterSpec(128, iv));
        byte[] ciphertext = cipher.doFinal(message);

        // Send to recipient: kemCiphertext, ciphertext, iv, signature, senderPubKey

        // ============================================================
        // 4. DECRYPT — recipient decapsulates + decrypts
        // ============================================================
        // ML-KEM decapsulate: recover the shared secret with private key
        byte[] recoveredSecret = provider.kemDecapsulate(
                kemCiphertext, recipientPrivKey, "ML-KEM-768");

        byte[] recoveredAesKey = MessageDigest.getInstance("SHA-256").digest(recoveredSecret);

        Cipher decCipher = Cipher.getInstance("AES/GCM/NoPadding");
        decCipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(recoveredAesKey, "AES"),
                        new GCMParameterSpec(128, iv));
        byte[] plaintext = decCipher.doFinal(ciphertext);

        // ============================================================
        // 5. VERIFY — recipient verifies the sender's signature
        // ============================================================
        boolean valid = provider.verify(
                plaintext, signature, senderKeys.getPublicKeyPem(), "ML-DSA-65");

        System.out.println("Decrypted: " + new String(plaintext));
        System.out.println("Signature valid: " + valid);
    }
}

// Cleanup at shutdown
provider.close();