#include <openssl/oqs.h>

int main(void) {
    EVP_PKEY *keypair = NULL;
    unsigned char *ct = NULL, *ss_enc = NULL, *ss_dec = NULL;
    size_t ct_len = 0, ss_enc_len = 0, ss_dec_len = 0;

    oqs_provider_load();
    oqs_kem_keygen(OQS_KEM_KYBER768, &keypair);
    oqs_kem_encapsulate(keypair, &ct, &ct_len, &ss_enc, &ss_enc_len);
    oqs_kem_decapsulate(keypair, ct, ct_len, &ss_dec, &ss_dec_len);
    /* 比较 shared secret …… */
}

#include "unified_crypto_interface.h"

// 初始化
uci_init();

// 生成密钥（适用于任何算法）
uci_keypair_t keypair;
uci_keygen(UCI_ALG_DILITHIUM2, &keypair);  // 或 UCI_ALG_RSA2048, UCI_ALG_SM2 等

// 签名
uci_signature_t signature;
uci_sign(&keypair, message, message_len, &signature);

// 验证
int result = uci_verify(&keypair, message, message_len, &signature);

// 清理
uci_signature_free(&signature);
uci_keypair_free(&keypair);
uci_cleanup();

#include "unified_crypto_interface.h"
#include <stdio.h>
#include <string.h>

int main() {
    uci_init();
    
    // 使用Dilithium2签名算法
    uci_keypair_t keypair;
    uci_keygen(UCI_ALG_DILITHIUM2, &keypair);
    
    const char *message = "Hello, Post-Quantum World!";
    uci_signature_t sig;
    
    if (uci_sign(&keypair, (uint8_t*)message, strlen(message), &sig) == UCI_SUCCESS) {
        printf("Signature created: %zu bytes\n", sig.data_len);
        
        if (uci_verify(&keypair, (uint8_t*)message, strlen(message), &sig) == UCI_SUCCESS) {
            printf("Signature verified successfully!\n");
        }
    }
    
    uci_signature_free(&sig);
    uci_keypair_free(&keypair);
    uci_cleanup();
    
    return 0;
}

#include "unified_crypto_interface.h"
#include <stdio.h>

int main() {
    uci_init();
    
    // 使用Kyber768 KEM
    uci_keypair_t keypair;
    uci_kem_keygen(UCI_ALG_KYBER768, &keypair);
    
    // 发送方：封装
    uci_kem_encaps_result_t result;
    uci_kem_encaps(&keypair, &result);
    
    printf("Shared secret: %zu bytes\n", result.shared_secret_len);
    printf("Ciphertext: %zu bytes\n", result.ciphertext_len);
    
    // 接收方：解封装
    uint8_t shared_secret[256];
    size_t secret_len = sizeof(shared_secret);
    uci_kem_decaps(&keypair, result.ciphertext, result.ciphertext_len,
                   shared_secret, &secret_len);
    
    printf("Decapsulated secret: %zu bytes\n", secret_len);
    
    uci_kem_encaps_result_free(&result);
    uci_keypair_free(&keypair);
    uci_cleanup();
    
    return 0;
}

#include "unified_crypto_interface.h"
#include <stdio.h>
#include <stdlib.h>

int main() {
    uci_init();
    
    // 查询所有抗量子算法
    size_t count = 0;
    uci_list_algorithms(UCI_ALG_TYPE_POST_QUANTUM, NULL, &count);
    
    uci_algorithm_id_t *algorithms = malloc(count * sizeof(uci_algorithm_id_t));
    uci_list_algorithms(UCI_ALG_TYPE_POST_QUANTUM, algorithms, &count);
    
    printf("Post-Quantum Algorithms:\n");
    for (size_t i = 0; i < count; i++) {
        uci_algorithm_info_t info;
        uci_get_algorithm_info(algorithms[i], &info);
        printf("  %s (Security: %d bits)\n", info.name, info.security_level);
    }
    
    free(algorithms);
    uci_cleanup();
    
    return 0;
}

// 当前使用RSA
uci_keygen(UCI_ALG_RSA2048, &keypair);

// 轻松切换到抗量子算法
uci_keygen(UCI_ALG_DILITHIUM2, &keypair);

// 或使用混合方案
uci_keygen(UCI_ALG_HYBRID_RSA_DILITHIUM, &keypair);

#include "unified_crypto_interface.h"

uci_init();
uci_keypair_t keypair;
uci_keygen(UCI_ALG_DILITHIUM2, &keypair);
uci_sign(&keypair, message, len, &signature);
uci_cleanup();

#include <openssl/evp.h>

// UCI Provider自动加载，无需修改应用代码
EVP_PKEY *pkey = EVP_PKEY_Q_keygen(NULL, NULL, "dilithium2");
EVP_MD_CTX *ctx = EVP_MD_CTX_new();
EVP_DigestSignInit(ctx, NULL, NULL, NULL, pkey);
// 使用标准OpenSSL API...

int uci_init(void);
int uci_cleanup(void);

int uci_keygen(uci_algorithm_id_t algorithm, uci_keypair_t *keypair);
int uci_kem_keygen(uci_algorithm_id_t algorithm, uci_keypair_t *keypair);
int uci_keypair_free(uci_keypair_t *keypair);

int uci_sign(const uci_keypair_t *keypair, const uint8_t *message, 
             size_t message_len, uci_signature_t *signature);
int uci_verify(const uci_keypair_t *keypair, const uint8_t *message, 
               size_t message_len, const uci_signature_t *signature);
int uci_signature_free(uci_signature_t *signature);

int uci_kem_encaps(const uci_keypair_t *keypair, uci_kem_encaps_result_t *result);
int uci_kem_decaps(const uci_keypair_t *keypair, const uint8_t *ciphertext, 
                   size_t ciphertext_len, uint8_t *shared_secret, size_t *shared_secret_len);
int uci_kem_encaps_result_free(uci_kem_encaps_result_t *result);

int uci_get_algorithm_info(uci_algorithm_id_t algorithm, uci_algorithm_info_t *info);
int uci_list_algorithms(uci_algorithm_type_t type, uci_algorithm_id_t *algorithms, size_t *count);

const char *uci_get_error_string(int error_code);