Flow 34 – Composite Key Rotation (COMPOSITE_KEM_COMBINE)

package co.ankatech.ankasecure.sdk.examples;

import co.ankatech.ankasecure.sdk.AuthenticatedSdk;
import co.ankatech.ankasecure.sdk.model.*;
import co.ankatech.secure.client.model.KeyRequest;

import java.nio.file.Path;

import static co.ankatech.ankasecure.sdk.examples.ExampleUtil.*;

/**
 * Scenario 34 — Composite Key Rotation and Migration.
 *
 * <p>Demonstrates key rotation patterns for composite keys including:</p>
 * <ul>
 *   <li>Rotating from simple to composite keys (classical → hybrid)</li>
 *   <li>Upgrading security level (X25519+ML-KEM-768 → X448+ML-KEM-1024)</li>
 *   <li>Rotating composite to composite with different components</li>
 *   <li>Verifying rotation chains</li>
 * </ul>
 *
 * <h3>Rotation Patterns:</h3>
 * <ol>
 *   <li>Simple RSA → Composite hybrid X25519+ML-KEM-768 (migration to PQC)</li>
 *   <li>X25519+ML-KEM-768 → X448+ML-KEM-1024 (security level upgrade)</li>
 *   <li>Composite with KDF upgrade (HKDF-SHA256 → HKDF-SHA512)</li>
 * </ol>
 *
 * @author ANKATech Solutions Inc.
 * @since 3.0.0
 */
public final class ExampleScenario34 {

    private static final Path TEMP_DIR = Path.of("temp_files");

    private ExampleScenario34() { }

    public static void main(String[] args) {
        try {
            System.out.println("=================================================================");
            System.out.println("  SCENARIO 34: Composite Key Rotation");
            System.out.println("=================================================================\n");

            ensureTempDir(TEMP_DIR);
            java.util.Properties props = loadProperties();
            AuthenticatedSdk sdk = authenticate(props);

            demonstrateSimpleToCompositeRotation(sdk);
            demonstrateCompositeToCompositeRotation(sdk);
            demonstrateKdfUpgrade(sdk);

            System.out.println("\n=================================================================");
            System.out.println("  ALL ROTATION PATTERNS DEMONSTRATED");
            System.out.println("=================================================================");

        } catch (Exception e) {
            fatal("Scenario 34 failed", e);
        }
    }

    /**
     * Pattern 1: Rotate simple RSA key to composite hybrid.
     */
    private static void demonstrateSimpleToCompositeRotation(AuthenticatedSdk sdk) throws Exception {
        System.out.println("[1/3] ROTATE SIMPLE → COMPOSITE (Classical → Hybrid)\n");

        // Create simple RSA key
        String simpleKid = "simple_rsa_" + System.currentTimeMillis();
        KeyRequest simpleRequest = new KeyRequest()
            .kid(simpleKid)
            .kty("RSA")
            .alg("RSA-4096");

        KeyMetadata simpleKey = sdk.generateKey(simpleRequest);
        System.out.println("      Original key created: " + simpleKey.getKid());
        System.out.println("      Type: " + simpleKey.getKty());
        System.out.println("      Algorithm: " + simpleKey.getAlg());
        System.out.println();

        // Rotate to composite hybrid
        // Note: X25519 (128-bit) pairs with ML-KEM-768 (Level 3) for balanced security
        // For ML-KEM-1024 (Level 5), use X448 or P-384/P-521
        String compositeKid = "hybrid_successor_" + System.currentTimeMillis();
        KeyRequest compositeRequest = new KeyRequest()
            .kid(compositeKid)
            .kty("COMPOSITE_KEM_COMBINE")
            .alg("X25519+ML-KEM-768")
            .kdf("HKDF-SHA256");

        System.out.println("      Rotating to hybrid key (X25519+ML-KEM-768)...");
        System.out.println("      Note: RSA supports sign/verify, COMPOSITE_KEM_COMBINE does not");
        System.out.println("            Acknowledging capability reduction...");

        // Must acknowledge capability reduction: RSA has sign/verify, KEM does not
        KeyMetadata rotated = sdk.rotateKey(simpleKid, compositeRequest, true);

        System.out.println("\n      ✅ Rotation complete");
        System.out.println("      New KID: " + rotated.getKid());
        System.out.println("      New Type: " + rotated.getKty());
        System.out.println("      New Algorithm: " + rotated.getAlg());
        System.out.println("      KDF: " + rotated.getKdf());
        System.out.println("      Previous KID: " + rotated.getPreviousKid());
        System.out.println("      Capability reduction: Lost sign/verify operations");
        System.out.println("      Migration: Classical RSA → Quantum-resistant hybrid\n");
    }

    /**
     * Pattern 2: Upgrade PQC component in composite key.
     */
    private static void demonstrateCompositeToCompositeRotation(AuthenticatedSdk sdk) throws Exception {
        System.out.println("[2/3] ROTATE COMPOSITE → COMPOSITE (Security Level Upgrade)\n");

        // Create Level 3 composite key (X25519 = 128-bit, ML-KEM-768 = Level 3)
        String level3Kid = "hybrid_level3_" + System.currentTimeMillis();
        KeyRequest level3Request = new KeyRequest()
            .kid(level3Kid)
            .kty("COMPOSITE_KEM_COMBINE")
            .alg("X25519+ML-KEM-768");      // Level 3 PQC

        KeyMetadata level3Key = sdk.generateKey(level3Request);
        System.out.println("      Original key: " + level3Key.getKid());
        System.out.println("      Algorithm: " + level3Key.getAlg() + " (X25519 + ML-KEM Level 3)");
        System.out.println();

        // Upgrade to Level 5
        // X448+ML-KEM-1024 provides balanced Level 5 security (both components ~192-256 bit)
        String level5Kid = "hybrid_level5_" + System.currentTimeMillis();
        KeyRequest level5Request = new KeyRequest()
            .kid(level5Kid)
            .kty("COMPOSITE_KEM_COMBINE")
            .alg("X448+ML-KEM-1024");       // Upgraded both classical and PQC

        System.out.println("      Upgrading to Level 5...");
        KeyMetadata upgraded = sdk.rotateKey(level3Kid, level5Request, false);

        System.out.println("\n      ✅ Security upgrade complete");
        System.out.println("      New Algorithm: " + upgraded.getAlg() + " (Level 5)");
        System.out.println("      Previous KID: " + upgraded.getPreviousKid());
        System.out.println("      Upgrade: X25519+ML-KEM-768 → X448+ML-KEM-1024\n");
    }

    /**
     * Pattern 3: Upgrade KDF in composite key.
     */
    private static void demonstrateKdfUpgrade(AuthenticatedSdk sdk) throws Exception {
        System.out.println("[3/3] ROTATE WITH KDF UPGRADE (SHA256 → SHA512)\n");

        // Create key with HKDF-SHA256
        String sha256Kid = "hybrid_sha256_" + System.currentTimeMillis();
        KeyRequest sha256Request = new KeyRequest()
            .kid(sha256Kid)
            .kty("COMPOSITE_KEM_COMBINE")
            .alg("X25519+ML-KEM-768")
            .kdf("HKDF-SHA256");

        KeyMetadata sha256Key = sdk.generateKey(sha256Request);
        System.out.println("      Original key: " + sha256Key.getKid());
        System.out.println("      KDF: " + sha256Key.getKdf());
        System.out.println();

        // Rotate with stronger KDF
        String sha512Kid = "hybrid_sha512_" + System.currentTimeMillis();
        KeyRequest sha512Request = new KeyRequest()
            .kid(sha512Kid)
            .kty("COMPOSITE_KEM_COMBINE")
            .alg("X25519+ML-KEM-768")
            .kdf("HKDF-SHA512");            // Stronger KDF

        System.out.println("      Upgrading KDF...");
        KeyMetadata upgraded = sdk.rotateKey(sha256Kid, sha512Request, false);

        System.out.println("\n      ✅ KDF upgrade complete");
        System.out.println("      New KDF: " + upgraded.getKdf());
        System.out.println("      Previous KID: " + upgraded.getPreviousKid());
        System.out.println("      Upgrade: HKDF-SHA256 → HKDF-SHA512\n");
    }
}

// Cannot change mode
Original: COMPOSITE_KEM_COMBINE
Successor: COMPOSITE_SIGNATURE
Result: InvalidInputException("Composite mode mismatch")

// Cannot change algorithms
Original: [X25519, ML-KEM-768]
Successor: [RSA-3072, ML-KEM-768]
Result: InvalidInputException("Component algorithm mismatch at index 0")

// Cannot downgrade to SIMPLE
Original: COMPOSITE (X25519 + ML-KEM-768)
Successor: SIMPLE (ML-KEM-1024)
Result: InvalidInputException("Cannot rotate COMPOSITE key to SIMPLE key")