luajitos

example_easycrypto.c (6324B)

---

 /*
  * Example program demonstrating EasyCrypto API
  */
 
 #include "EasyCrypto.h"
 #include <stdio.h>
 #include <string.h>
 
 int main(void) {
     printf("EasyCrypto Demo\n");
     printf("===============\n\n");
 
     // Initialize the library
     easycrypto_init();
 
     // Generate a random key
     uint8_t key[32];
     easycrypto_generate_key(key);
     easycrypto_set_key(key);
 
     printf("Generated 256-bit key:\n");
     easycrypto_print_hex("Key", key, 32);
     printf("\n");
 
     // Test data
     const char *message = "Hello, EasyCrypto! This is a secret message.";
     printf("Original message: %s\n\n", message);
 
     // ==========================================
     // Test 1: AES-256-GCM (default - 2 args)
     // ==========================================
     printf("Test 1: AES-256-GCM (default)\n");
     printf("------------------------------\n");
 
     CryptoResult encrypted_aes = ENCRYPT((uint8_t*)message, strlen(message));
 
     if (encrypted_aes.success) {
         printf("Encryption successful!\n");
         printf("Encrypted size: %zu bytes\n", encrypted_aes.length);
         easycrypto_print_hex("Encrypted", encrypted_aes.data, encrypted_aes.length);
         printf("\n");
 
         // Decrypt
         CryptoResult decrypted_aes = DECRYPT(encrypted_aes.data, encrypted_aes.length);
 
         if (decrypted_aes.success) {
             printf("Decryption successful!\n");
             printf("Decrypted message: %.*s\n\n", (int)decrypted_aes.length, decrypted_aes.data);
 
             // Verify
             if (memcmp(message, decrypted_aes.data, strlen(message)) == 0) {
                 printf("✓ AES-256-GCM: Message verified!\n\n");
             } else {
                 printf("✗ AES-256-GCM: Verification failed!\n\n");
             }
 
             easycrypto_free(&decrypted_aes);
         } else {
             printf("✗ Decryption failed!\n\n");
         }
 
         easycrypto_free(&encrypted_aes);
     } else {
         printf("✗ Encryption failed!\n\n");
     }
 
     // ==========================================
     // Test 2: Serpent-256-GCM (explicit - 3 args)
     // ==========================================
     printf("Test 2: Serpent-256-GCM (explicit)\n");
     printf("----------------------------------\n");
 
     CryptoResult encrypted_serpent = ENCRYPT(SERPENT_256_GCM, (uint8_t*)message, strlen(message));
 
     if (encrypted_serpent.success) {
         printf("Encryption successful!\n");
         printf("Encrypted size: %zu bytes\n", encrypted_serpent.length);
         easycrypto_print_hex("Encrypted", encrypted_serpent.data, encrypted_serpent.length);
         printf("\n");
 
         // Decrypt
         CryptoResult decrypted_serpent = DECRYPT(encrypted_serpent.data, encrypted_serpent.length);
 
         if (decrypted_serpent.success) {
             printf("Decryption successful!\n");
             printf("Decrypted message: %.*s\n\n", (int)decrypted_serpent.length, decrypted_serpent.data);
 
             // Verify
             if (memcmp(message, decrypted_serpent.data, strlen(message)) == 0) {
                 printf("✓ Serpent-256-GCM: Message verified!\n\n");
             } else {
                 printf("✗ Serpent-256-GCM: Verification failed!\n\n");
             }
 
             easycrypto_free(&decrypted_serpent);
         } else {
             printf("✗ Decryption failed!\n\n");
         }
 
         easycrypto_free(&encrypted_serpent);
     } else {
         printf("✗ Encryption failed!\n\n");
     }
 
     // ==========================================
     // Test 3: With AAD (Additional Authenticated Data)
     // ==========================================
     printf("Test 3: AES-256-GCM with AAD\n");
     printf("-----------------------------\n");
 
     const char *aad_data = "metadata:user=alice,timestamp=123456";
     printf("AAD: %s\n", aad_data);
 
     CryptoResult encrypted_with_aad = easycrypto_encrypt(
         AES_256_GCM,
         (uint8_t*)message, strlen(message),
         (uint8_t*)aad_data, strlen(aad_data)
     );
 
     if (encrypted_with_aad.success) {
         printf("Encryption with AAD successful!\n");
 
         // Decrypt with AAD
         CryptoResult decrypted_with_aad = easycrypto_decrypt(
             encrypted_with_aad.data, encrypted_with_aad.length,
             (uint8_t*)aad_data, strlen(aad_data)
         );
 
         if (decrypted_with_aad.success) {
             printf("Decryption with AAD successful!\n");
             printf("Decrypted message: %.*s\n", (int)decrypted_with_aad.length, decrypted_with_aad.data);
             printf("✓ AAD authentication passed!\n\n");
             easycrypto_free(&decrypted_with_aad);
         } else {
             printf("✗ Decryption with AAD failed!\n\n");
         }
 
         // Try to decrypt with wrong AAD (should fail)
         printf("Testing with wrong AAD...\n");
         const char *wrong_aad = "wrong metadata";
         CryptoResult decrypted_wrong_aad = easycrypto_decrypt(
             encrypted_with_aad.data, encrypted_with_aad.length,
             (uint8_t*)wrong_aad, strlen(wrong_aad)
         );
 
         if (!decrypted_wrong_aad.success) {
             printf("✓ Correctly rejected wrong AAD!\n\n");
         } else {
             printf("✗ Should have rejected wrong AAD!\n\n");
             easycrypto_free(&decrypted_wrong_aad);
         }
 
         easycrypto_free(&encrypted_with_aad);
     } else {
         printf("✗ Encryption with AAD failed!\n\n");
     }
 
     // ==========================================
     // Test 4: Tamper detection
     // ==========================================
     printf("Test 4: Tamper detection\n");
     printf("------------------------\n");
 
     CryptoResult encrypted_tamper = ENCRYPT((uint8_t*)message, strlen(message));
 
     if (encrypted_tamper.success) {
         // Corrupt a byte in the ciphertext
         encrypted_tamper.data[20] ^= 0xFF;
 
         printf("Corrupted ciphertext, attempting decrypt...\n");
         CryptoResult decrypted_tamper = DECRYPT(encrypted_tamper.data, encrypted_tamper.length);
 
         if (!decrypted_tamper.success) {
             printf("✓ Correctly detected tampering!\n\n");
         } else {
             printf("✗ Should have detected tampering!\n\n");
             easycrypto_free(&decrypted_tamper);
         }
 
         easycrypto_free(&encrypted_tamper);
     }
 
     printf("All tests completed!\n");
 
     return 0;
 }