Encrypted Data Functions

void analyze_encrypted_data(kc_encrypted_data_t* encrypted) {
    // Check if data is valid
    bool is_null = false;
    int result = kc_encrypted_data_is_null(encrypted, &is_null);
    if (result != 0 || is_null) {
        printf("Encrypted data is null or invalid\n");
        return;
    }

    // Get encryption algorithm
    tkc_cipher cipher_alg;
    result = kc_encrypted_data_algorithm(encrypted, &cipher_alg);
    if (result == 0) {
        printf("Encryption algorithm: ");
        switch (cipher_alg) {
            case TKC_CIPHER_AES_256_GCM:
                printf("AES-256-GCM\n");
                break;
            case TKC_CIPHER_AES_128_GCM:
                printf("AES-128-GCM\n");
                break;
            case TKC_CIPHER_CHACHA20_POLY1305:
                printf("ChaCha20-Poly1305\n");
                break;
            default:
                printf("Algorithm %d\n", cipher_alg);
        }
    }

    // Get IV
    char* iv_hex = NULL;
    unsigned int iv_size = 0;
    result = kc_encrypted_data_iv(encrypted, &iv_hex, &iv_size);
    if (result == 0) {
        printf("IV (%u bytes): %.*s\n", iv_size/2, iv_size, iv_hex);
        kc_common_delete_buffer(&iv_hex);
    }

    // Get ciphertext size
    char* ciphertext = NULL;
    unsigned int ciphertext_size = 0;
    result = kc_encrypted_data_ciphertext(encrypted, &ciphertext, &ciphertext_size);
    if (result == 0) {
        printf("Ciphertext size: %u bytes\n", ciphertext_size);
        kc_common_delete_buffer(&ciphertext);
    }

    // Check access control
    unsigned int recipient_count = 0;
    result = kc_encrypted_data_num_key_locks(encrypted, &recipient_count);
    if (result == 0) {
        printf("Number of authorized recipients: %u\n", recipient_count);

        // List each recipient
        for (unsigned int i = 0; i < recipient_count; i++) {
            kc_key_lock_t* key_lock = NULL;
            result = kc_encrypted_data_key_lock(encrypted, &key_lock, i);
            if (result == 0) {
                printf("  Recipient %u: ", i + 1);

                // Get public key from key lock
                char* pubkey = NULL;
                unsigned int pubkey_size = 0;
                if (kc_key_lock_public_key(key_lock, &pubkey, &pubkey_size) == 0) {
                    printf("Public key: %.16s...\n", pubkey);
                    kc_common_delete_buffer(&pubkey);
                }

                kc_key_lock_destruct(&key_lock);
            }
        }
    }
}

// Complete encryption/decryption example
void demonstrate_encryption_workflow(kc_gateway_t* gateway) {
    kc_persona_t* alice = NULL;
    kc_persona_t* bob = NULL;
    kc_contact_t* bob_contact = NULL;

    // Get personas and contacts (implementation omitted)
    // ...

    // Create data to encrypt
    const char* secret_message = "Confidential: Project Phoenix launch date is March 15";
    kc_serialized_data_t* plaintext = NULL;
    int result = kc_serialized_data_construct_from_string(&plaintext,
        secret_message, strlen(secret_message), TKC_DATA_TYPE_UTF8_STRING);

    if (result != 0) {
        printf("Failed to create serialized data\n");
        return;
    }

    // Alice encrypts for Bob
    kc_encrypted_data_t* encrypted = NULL;
    const kc_contact_t* recipients[] = {bob_contact};
    result = kc_gateway_encrypt(gateway, &encrypted, alice, plaintext, recipients, 1);

    if (result == 0) {
        printf("Message encrypted successfully\n");

        // Analyze the encrypted data
        analyze_encrypted_data(encrypted);

        // Serialize for transmission
        char* encrypted_json = NULL;
        unsigned int json_size = 0;
        result = kc_encrypted_data_serialize_to_string(encrypted, &encrypted_json,
                                                      &json_size,
                                                      TKC_SERIALIZATION_FORMAT_JSON);
        if (result == 0) {
            printf("\nEncrypted data as JSON (%u bytes):\n", json_size);
            printf("%.200s...\n", encrypted_json);  // Show first 200 chars

            // Bob receives and reconstructs the encrypted data
            kc_encrypted_data_t* received_encrypted = NULL;
            result = kc_encrypted_data_construct_from_serialized_string(
                &received_encrypted, encrypted_json, json_size,
                TKC_SERIALIZATION_FORMAT_JSON);

            if (result == 0) {
                // Bob decrypts the message
                kc_serialized_data_t* decrypted = NULL;
                result = kc_gateway_decrypt(gateway, &decrypted, bob, received_encrypted);

                if (result == 0) {
                    char* decrypted_text = NULL;
                    unsigned int text_size = 0;
                    kc_serialized_data_content(decrypted, &decrypted_text, &text_size);

                    printf("\nBob decrypted message: %.*s\n", text_size, decrypted_text);

                    kc_common_delete_buffer(&decrypted_text);
                    kc_serialized_data_destruct(&decrypted);
                } else {
                    printf("Bob failed to decrypt message\n");
                }

                kc_encrypted_data_destruct(&received_encrypted);
            }

            kc_common_delete_buffer(&encrypted_json);
        }

        kc_encrypted_data_destruct(&encrypted);
    } else {
        printf("Encryption failed: %d\n", result);
    }

    // Cleanup
    kc_serialized_data_destruct(&plaintext);
    if (alice) kc_persona_destruct(&alice);
    if (bob) kc_persona_destruct(&bob);
    if (bob_contact) kc_contact_destruct(&bob_contact);
}