luajitos

example_persistence.c (6430B)

---

 /*
  * Example: Saving and Loading Encrypted Data
  *
  * Demonstrates how to:
  * 1. Encrypt data
  * 2. Serialize it to bytes
  * 3. Save to a file
  * 4. Load from file after restart
  * 5. Deserialize and decrypt
  */
 
 #include "EasyCrypto.h"
 #include "CSPRNG.h"
 #include <stdio.h>
 #include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 /* Save bytes to file */
 int save_to_file(const char *filename, const uint8_t *data, size_t len) {
     int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
     if (fd < 0) {
         perror("Failed to open file for writing");
         return -1;
     }
 
     ssize_t written = write(fd, data, len);
     close(fd);
 
     if (written != (ssize_t)len) {
         fprintf(stderr, "Failed to write all data to file\n");
         return -1;
     }
 
     return 0;
 }
 
 /* Load bytes from file */
 uint8_t* load_from_file(const char *filename, size_t *len) {
     int fd = open(filename, O_RDONLY);
     if (fd < 0) {
         perror("Failed to open file for reading");
         return NULL;
     }
 
     /* Get file size */
     off_t file_size = lseek(fd, 0, SEEK_END);
     if (file_size < 0) {
         close(fd);
         return NULL;
     }
     lseek(fd, 0, SEEK_SET);
 
     /* Allocate buffer */
     uint8_t *buffer = malloc(file_size);
     if (!buffer) {
         close(fd);
         return NULL;
     }
 
     /* Read file */
     ssize_t bytes_read = read(fd, buffer, file_size);
     close(fd);
 
     if (bytes_read != file_size) {
         free(buffer);
         return NULL;
     }
 
     *len = file_size;
     return buffer;
 }
 
 int main(void) {
     printf("╔════════════════════════════════════════════════════╗\n");
     printf("║   Encrypted Data Persistence Example              ║\n");
     printf("╚════════════════════════════════════════════════════╝\n\n");
 
     /* Initialize CSPRNG */
     csprng_global_init();
 
     /* Generate encryption key */
     uint8_t key[32];
     random_bytes(key, 32);
 
     printf("Step 1: Generate encryption key\n");
     printf("Key: ");
     for (int i = 0; i < 16; i++) printf("%02x", key[i]);
     printf("...\n\n");
 
     /* Data to encrypt */
     const char *secret_message = "This is confidential data that needs to survive a reboot!";
     printf("Step 2: Original message\n");
     printf("\"%s\"\n\n", secret_message);
 
     /* Encrypt the data */
     printf("Step 3: Encrypt with Twofish-256-GCM\n");
     size_t encrypted_len;
     void *encrypted = ENCRYPT_TWOFISH(key, (uint8_t*)secret_message, strlen(secret_message), &encrypted_len);
     if (!encrypted) {
         fprintf(stderr, "✗ Encryption failed\n");
         return 1;
     }
     printf("✓ Encrypted successfully\n");
     printf("  Format: [Nonce(12)][Tag(16)][Ciphertext(var)]\n");
     printf("  Total length: %zu bytes\n", encrypted_len);
     printf("  Breakdown:\n");
     printf("    - Nonce: 12 bytes\n");
     printf("    - Tag: 16 bytes\n");
     printf("    - Ciphertext: %zu bytes\n\n", encrypted_len - 28);
 
     /* Save to file */
     printf("Step 4: Save to file 'encrypted_data.bin'\n");
     if (save_to_file("encrypted_data.bin", encrypted, encrypted_len) != 0) {
         fprintf(stderr, "✗ Failed to save to file\n");
         free(encrypted);
         return 1;
     }
     printf("✓ Saved %zu bytes to encrypted_data.bin\n", encrypted_len);
     printf("  First 32 bytes: ");
     for (size_t i = 0; i < 32 && i < encrypted_len; i++) {
         printf("%02x", ((uint8_t*)encrypted)[i]);
     }
     printf("...\n\n");
 
     /* Clean up */
     free(encrypted);
 
     printf("════════════════════════════════════════════════════\n");
     printf("SIMULATING RESTART - All memory is cleared\n");
     printf("════════════════════════════════════════════════════\n\n");
 
     /* Load from file */
     printf("Step 5: Load from file after 'restart'\n");
     size_t loaded_len;
     uint8_t *loaded = load_from_file("encrypted_data.bin", &loaded_len);
     if (!loaded) {
         fprintf(stderr, "✗ Failed to load from file\n");
         return 1;
     }
     printf("✓ Loaded %zu bytes from encrypted_data.bin\n", loaded_len);
     printf("  Format: [Nonce(12)][Tag(16)][Ciphertext(%zu)]\n", loaded_len - 28);
     printf("  First 32 bytes: ");
     for (size_t i = 0; i < 32 && i < loaded_len; i++) {
         printf("%02x", loaded[i]);
     }
     printf("...\n\n");
 
     /* Decrypt */
     printf("Step 6: Decrypt using the same key\n");
     size_t decrypted_len;
     void *decrypted = DECRYPT_TWOFISH(key, loaded, loaded_len, &decrypted_len);
     free(loaded);
 
     if (!decrypted) {
         fprintf(stderr, "✗ Decryption failed\n");
         return 1;
     }
 
     printf("✓ Decrypted successfully\n");
     printf("  Recovered message: \"");
     fwrite(decrypted, 1, decrypted_len, stdout);
     printf("\"\n\n");
 
     /* Verify */
     if (decrypted_len == strlen(secret_message) &&
         memcmp(decrypted, secret_message, decrypted_len) == 0) {
         printf("✓ SUCCESS! Message survived the 'restart'\n\n");
     } else {
         printf("✗ FAILED! Message was corrupted\n\n");
     }
 
     free(decrypted);
 
     /* Clean up */
     unlink("encrypted_data.bin");
 
     printf("════════════════════════════════════════════════════\n");
     printf("Key Points:\n");
     printf("════════════════════════════════════════════════════\n");
     printf("• ENCRYPT_TWOFISH returns void* with [Nonce][Tag][Ciphertext]\n");
     printf("• Format: [Nonce(12)][Tag(16)][Ciphertext(var)]\n");
     printf("• NO metadata - algorithm/lengths tracked externally\n");
     printf("• Direct to bytes - no serialization needed\n");
     printf("• Save bytes directly to disk/database/network\n");
     printf("• DECRYPT_TWOFISH reads the same format\n");
     printf("• Simple API: just encrypt, save, load, decrypt\n\n");
 
     /* Zero sensitive data */
     memset(key, 0, 32);
 
     return 0;
 }