luajitos

easycrypto_demo.c (8320B)

---

 /*
  * EasyCrypto Demo
  * Shows simple encryption API usage
  */
 
 #include "EasyCrypto.h"
 #include "PBKDF2.h"
 #include <stdio.h>
 
 int main(void) {
     printf("╔════════════════════════════════════════════════════╗\n");
     printf("║   EasyCrypto - Simple Encryption API              ║\n");
     printf("╚════════════════════════════════════════════════════╝\n\n");
 
     printf("Features:\n");
     printf("• Simple ENCRYPT(key, data, len) macro\n");
     printf("• Automatic nonce generation\n");
     printf("• Authenticated encryption (AEAD)\n");
     printf("• Default: AES-256-GCM (hardware accelerated)\n");
     printf("• Alternative: ChaCha20-Poly1305\n\n");
 
     // Initialize global CSPRNG
     csprng_global_init();
 
     printf("════════════════════════════════════════════════════\n");
     printf("Example 1: Encrypt with Generated Key\n");
     printf("════════════════════════════════════════════════════\n\n");
 
     // Generate a random key
     uint8_t key[32];
     random_bytes(key, 32);
 
     printf("Generated key: ");
     for (int i = 0; i < 16; i++) printf("%02x", key[i]);
     printf("...\n\n");
 
     // Message to encrypt
     const char *message = "Hello, EasyCrypto! This is a secret message.";
     printf("Message: \"%s\"\n\n", message);
 
     // Encrypt (uses AES-256-GCM by default)
     encrypted_data *enc = ENCRYPT(key, (uint8_t*)message, strlen(message));
     if (!enc) {
         fprintf(stderr, "✗ Encryption failed\n");
         return 1;
     }
 
     printf("✓ Encrypted successfully\n");
     printf("  Algorithm: AES-256-GCM\n");
     printf("  Nonce: ");
     for (size_t i = 0; i < enc->nonce_len; i++) {
         printf("%02x", enc->nonce[i]);
     }
     printf("\n");
     printf("  Ciphertext (%zu bytes): ", enc->ciphertext_len);
     for (size_t i = 0; i < (enc->ciphertext_len < 32 ? enc->ciphertext_len : 32); i++) {
         printf("%02x", enc->ciphertext[i]);
     }
     if (enc->ciphertext_len > 32) printf("...");
     printf("\n");
     printf("  Tag: ");
     for (size_t i = 0; i < enc->tag_len; i++) {
         printf("%02x", enc->tag[i]);
     }
     printf("\n\n");
 
     // Decrypt
     size_t dec_len;
     uint8_t *decrypted = DECRYPT(key, enc, &dec_len);
     if (!decrypted) {
         fprintf(stderr, "✗ Decryption failed\n");
         encrypted_data_free(enc);
         return 1;
     }
 
     printf("✓ Decrypted successfully\n");
     printf("  Message: \"");
     fwrite(decrypted, 1, dec_len, stdout);
     printf("\"\n\n");
 
     // Verify
     if (dec_len == strlen(message) && memcmp(decrypted, message, dec_len) == 0) {
         printf("✓ Encryption/Decryption verified!\n\n");
     }
 
     // Cleanup
     encrypted_data_free(enc);
     free(decrypted);
 
     printf("════════════════════════════════════════════════════\n");
     printf("Example 2: Encrypt with Password (PBKDF2)\n");
     printf("════════════════════════════════════════════════════\n\n");
 
     // Derive key from password
     const char *password = "super secret password";
     uint8_t salt[16];
     random_bytes(salt, 16);
 
     uint8_t derived_key[32];
 
     printf("Password: \"%s\"\n", password);
     printf("Salt: ");
     for (int i = 0; i < 16; i++) printf("%02x", salt[i]);
     printf("\n");
     printf("Deriving key with PBKDF2 (100,000 iterations)...\n");
 
     if (pbkdf2_hmac_sha256((uint8_t*)password, strlen(password),
                           salt, 16, PBKDF2_ITERATIONS_MIN,
                           derived_key, 32) != 0) {
         fprintf(stderr, "✗ Key derivation failed\n");
         return 1;
     }
 
     printf("Derived key: ");
     for (int i = 0; i < 16; i++) printf("%02x", derived_key[i]);
     printf("...\n\n");
 
     // Encrypt with derived key
     const char *secret = "This data is protected by a password!";
     printf("Secret data: \"%s\"\n\n", secret);
 
     encrypted_data *enc2 = ENCRYPT(derived_key, (uint8_t*)secret, strlen(secret));
     if (!enc2) {
         fprintf(stderr, "✗ Encryption failed\n");
         return 1;
     }
 
     printf("✓ Encrypted with password-derived key\n");
     printf("  Ciphertext: ");
     for (size_t i = 0; i < (enc2->ciphertext_len < 32 ? enc2->ciphertext_len : 32); i++) {
         printf("%02x", enc2->ciphertext[i]);
     }
     if (enc2->ciphertext_len > 32) printf("...");
     printf("\n\n");
 
     // Decrypt
     uint8_t *dec2 = DECRYPT(derived_key, enc2, &dec_len);
     if (!dec2) {
         fprintf(stderr, "✗ Decryption failed\n");
         encrypted_data_free(enc2);
         return 1;
     }
 
     printf("✓ Decrypted: \"");
     fwrite(dec2, 1, dec_len, stdout);
     printf("\"\n\n");
 
     encrypted_data_free(enc2);
     free(dec2);
 
     printf("════════════════════════════════════════════════════\n");
     printf("Example 3: Algorithm Selection\n");
     printf("════════════════════════════════════════════════════\n\n");
 
     const char *data = "Test message";
 
     // AES (default)
     encrypted_data *enc_aes = ENCRYPT_AES(key, (uint8_t*)data, strlen(data));
     printf("✓ AES-256-GCM:      Encrypted %zu bytes → %zu bytes + 16-byte tag\n",
            strlen(data), enc_aes->ciphertext_len);
 
     // ChaCha20
     encrypted_data *enc_chacha = ENCRYPT_CHACHA(key, (uint8_t*)data, strlen(data));
     printf("✓ ChaCha20-Poly1305: Encrypted %zu bytes → %zu bytes + 16-byte tag\n",
            strlen(data), enc_chacha->ciphertext_len);
 
     // Decrypt both
     uint8_t *dec_aes = DECRYPT_AES(key, enc_aes, &dec_len);
     uint8_t *dec_chacha = DECRYPT_CHACHA(key, enc_chacha, &dec_len);
 
     printf("\n✓ Both algorithms work correctly\n\n");
 
     encrypted_data_free(enc_aes);
     encrypted_data_free(enc_chacha);
     free(dec_aes);
     free(dec_chacha);
 
     printf("════════════════════════════════════════════════════\n");
     printf("Example 4: Authentication Verification\n");
     printf("════════════════════════════════════════════════════\n\n");
 
     encrypted_data *enc3 = ENCRYPT(key, (uint8_t*)message, strlen(message));
 
     printf("Original tag: ");
     for (size_t i = 0; i < 8; i++) printf("%02x", enc3->tag[i]);
     printf("...\n");
 
     // Corrupt the tag
     enc3->tag[0] ^= 0x01;
     printf("Corrupted tag: ");
     for (size_t i = 0; i < 8; i++) printf("%02x", enc3->tag[i]);
     printf("...\n\n");
 
     uint8_t *dec3 = DECRYPT(key, enc3, &dec_len);
     if (dec3) {
         printf("✗ Should have rejected corrupted data!\n");
         free(dec3);
     } else {
         printf("✓ Correctly rejected corrupted data\n");
     }
 
     encrypted_data_free(enc3);
 
     printf("\n════════════════════════════════════════════════════\n");
     printf("Summary:\n");
     printf("════════════════════════════════════════════════════\n");
     printf("• ENCRYPT/DECRYPT - Simple, secure API\n");
     printf("• AES-256-GCM default (hardware accelerated)\n");
     printf("• Automatic nonce generation\n");
     printf("• Authentication included (AEAD)\n");
     printf("• Works with PBKDF2 for password-based encryption\n");
     printf("• Production-ready\n");
 
     // Zero sensitive data
     memset(key, 0, 32);
     memset(derived_key, 0, 32);
 
     return 0;
 }