Flow 4 – Streaming Re-encrypt RSA-2048 ➜ ML-KEM-1024
This scenario performs a zero-plaintext-exposure migration from a classical RSA key to a post-quantum ML-KEM key:
- Generate an RSA-2048 key.
- Stream-encrypt a file (detached JWET).
- Generate an ML-KEM-1024 key.
- Stream-re-encrypt the ciphertext on the server (RSA → KEM).
- Stream-decrypt with the ML-KEM key.
- Validate the recovered plaintext.
Key points
- End-to-end streaming pipeline--encryptFileStream → reencryptFileStream → decryptFileStream--so even multi-gigabyte files never hit memory in one piece.
- Uses a detached JWET (General-JSON header + raw binary part), eliminating Base64 overhead during transfer.
- Zero-plaintext migration – the server converts RSA ciphertext to ML-KEM ciphertext without ever decrypting or returning sensitive data.
- Demonstrates live crypto-agility: two independent keys, negotiated algorithms, and rich lifecycle telemetry (actual key used, warnings, migration-mode flag).
When to use it
- Post-quantum retrofits – you already have archives protected with RSA and need to harden them against future quantum attacks without re-downloading or re-encrypting locally.
- Massive data lakes & backups – streaming re-encryption lets you upgrade multi-terabyte stores in place, one pass, no staging disk, no plaintext ever written.
- Regulated environments – proves to auditors that secret material stays encrypted end-to-end while cryptographic strength is increased.
- Maintenance windows – server-side key migration is quicker than a full decrypt/re-encrypt cycle, reducing downtime for business-critical datasets.
Shared helper —
ExampleUtil(configuration-loading, authentication, JSON, etc.).
If you haven’t copied it yet, fetch example_util.md and place the Java file beside the scenario sources.
Complete Java implementation
src/main/java/co/ankatech/ankasecure/sdk/examples/ExampleScenario4.java
/* *****************************************************************************
* FILE: ExampleScenario4.java
* ****************************************************************************/
package co.ankatech.ankasecure.sdk.examples;
import co.ankatech.ankasecure.sdk.AnkaSecureSdk;
import co.ankatech.ankasecure.sdk.model.DecryptResultMetadata;
import co.ankatech.ankasecure.sdk.model.EncryptResult;
import co.ankatech.ankasecure.sdk.model.GenerateKeySpec;
import co.ankatech.ankasecure.sdk.model.ReencryptResult;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import static co.ankatech.ankasecure.sdk.examples.ExampleUtil.*;
/**
* <h2>Scenario 4 – Streaming Re-encrypt (RSA-2048 → ML-KEM-1024)</h2>
*
* <p>This scenario demonstrates how to migrate classical RSA-encrypted data to
* a post-quantum ML-KEM-encrypted format <em>without exposing plaintext</em>.
* All cryptographic operations use the <strong>streaming</strong> API, meaning
* the service exchanges a two-part <em>detached JWE</em>
* (General-JSON header + raw ciphertext stream).</p>
*
* <ol>
* <li>Generate an {@code RSA-2048} key.</li>
* <li>Stream-encrypt a file (detached JWE).</li>
* <li>Generate an {@code ML-KEM-1024} key.</li>
* <li>Re-encrypt the ciphertext on the server (RSA → KEM).</li>
* <li>Stream-decrypt with the KEM key.</li>
* <li>Validate round-trip integrity.</li>
* </ol>
*
* <p>Temporary artefacts are placed under <kbd>temp_files/</kbd>.</p>
*
* <p><b>Implementation notes (Java 21+):</b></p>
* <ul>
* <li>All file operations rely on the {@link java.nio.file.Path} API.</li>
* <li>Encoding is explicitly set to UTF-8 for deterministic behaviour.</li>
* <li>Directory creation delegates to {@link ExampleUtil#ensureTempDir(Path)}.</li>
* </ul>
*
* <p><b>Thread-safety:</b> this class is stateless and immutable.</p>
*
* @author ANKATech – Security Engineering
* @since 2.1.0
*/
public final class ExampleScenario4 {
/* ====================================================================== */
/**
* Entry-point.
*
* @param args ignored
*/
public static void main(final String[] args) {
System.out.println("===== SCENARIO 4 START =====");
System.out.println("""
Purpose :
* RSA-2048 → ML-KEM-1024 streaming re-encryption
* Demonstrates detached-JWE pipeline (encrypt → re-encrypt → decrypt)
--------------------------------------------------------------""");
try {
ensureTempDir(TEMP_DIR);
Properties props = loadProperties();
AnkaSecureSdk sdk = authenticate(props);
runScenario(sdk);
} catch (Exception ex) {
fatal("Scenario 4 failed", ex);
}
System.out.println("===== SCENARIO 4 END =====");
}
/* ====================================================================== */
/**
* Executes a streaming re-encryption scenario for large files using the AnkaSecureSdk.
* <p>
* This method demonstrates end-to-end streaming encryption under RSA-2048,
* one-pass re-encryption to ML-KEM-1024, and streaming decryption, all without
* buffering entire files in memory.
*
* @param sdk the AnkaSecureSdk instance to use for all operations
* @throws Exception on any I/O or cryptographic failure
*/
private static void runScenario(final AnkaSecureSdk sdk) throws Exception {
/* 1 ── prepare large plaintext file (e.g., 10 MB) --------------------- */
Path plainFile = TEMP_DIR.resolve("scenario4_plain_large.bin");
byte[] dummy = new byte[10 * 1024 * 1024]; // zero-filled 10 MB buffer
Files.write(plainFile, dummy);
System.out.println("[1] Plaintext ready -> " + plainFile.toAbsolutePath());
/* 2 ── generate RSA-2048 key ----------------------------------------- */
String rsaKid = "sc4_rsa_" + System.currentTimeMillis();
sdk.generateKey(new GenerateKeySpec()
.setKid(rsaKid)
.setKty("RSA")
.setAlg("RSA-2048"));
System.out.println("[2] RSA-2048 key created -> kid = " + rsaKid);
/* 3 ── streaming encrypt under RSA-2048 ------------------------------ */
Path rsaCipher = TEMP_DIR.resolve("scenario4_rsa_large.enc");
EncryptResult rsaEncMeta = sdk.encryptFileStream(rsaKid, plainFile, rsaCipher);
System.out.println("[3] RSA ciphertext written -> " + rsaCipher.toAbsolutePath());
printEncryptMeta(rsaEncMeta);
/* 4 ── generate ML-KEM-1024 key ------------------------------------- */
String kemKid = "sc4_kem_" + System.currentTimeMillis();
sdk.generateKey(new GenerateKeySpec()
.setKid(kemKid)
.setKty("ML-KEM")
.setAlg("ML-KEM-1024"));
System.out.println("[4] ML-KEM-1024 key created -> kid = " + kemKid);
/* 5 ── one-pass streaming re-encrypt RSA → ML-KEM ---------------------- */
Path kemCipher = TEMP_DIR.resolve("scenario4_kem_large.enc");
ReencryptResult reMeta = sdk.reencryptFileStream(kemKid, rsaCipher, kemCipher);
System.out.println("[5] Re-encrypted file -> " + kemCipher.toAbsolutePath());
printReencryptMeta(reMeta);
/* 6 ── streaming decrypt under ML-KEM-1024 --------------------------- */
Path decFile = TEMP_DIR.resolve("scenario4_large_decrypted.bin");
DecryptResultMetadata decMeta = sdk.decryptFileStream(kemCipher, decFile);
System.out.println("[6] Decrypted file -> " + decFile.toAbsolutePath());
printDecryptMeta(decMeta);
/* 7 ── validation via streaming compare ------------------------------ */
try (InputStream in1 = Files.newInputStream(plainFile);
InputStream in2 = Files.newInputStream(decFile)) {
boolean match = streamsAreEqual(in1, in2);
System.out.println(match
? "[7] Validation OK – plaintext matches."
: "[7] WARNING – plaintext mismatch!");
}
}
/**
* Private constructor prevents instantiation.
*/
private ExampleScenario4() {
/* utility class – no instantiation */
}
}
How to run
Sequence to watch:
-
RSA-2048 key creation & stream-encryption.
-
ML-KEM-1024 key creation.
-
Server-side re-encrypt (RSA → KEM).
-
Stream-decryption with KEM key.
-
Validation OK proving lossless migration.