luajitos

EasyCrypto_simple.c (5568B)

---

 /*
  * EasyCrypto.c - Simple wrapper implementation
  * Links against crypto_aes.o and crypto_serpent.o
  */
 
 #include "EasyCrypto.h"
 #include "crypto_core.h"
 #include "CSPRNG.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <time.h>
 
 // Global key storage
 uint8_t EASYCRYPTO_KEY[32] = {0};
 
 // Initialized flag
 static int g_initialized = 0;
 
 // Generate random bytes using global CSPRNG
 static void generate_random_bytes(uint8_t *buf, size_t len) {
     random_bytes(buf, len);
 }
 
 void easycrypto_init(void) {
     if (!g_initialized) {
         crypto_detect_features();
         g_initialized = 1;
     }
 }
 
 void easycrypto_set_key(const uint8_t *key) {
     memcpy(EASYCRYPTO_KEY, key, 32);
 }
 
 void easycrypto_generate_key(uint8_t *key) {
     generate_random_bytes(key, 32);
 }
 
 CryptoResult easycrypto_encrypt(CryptoAlgorithm algo, const uint8_t *plaintext,
                                 size_t plaintext_len, const uint8_t *aad, size_t aad_len) {
     CryptoResult result = {NULL, 0, 0};
 
     if (!g_initialized) {
         easycrypto_init();
     }
 
     // Check if key is set
     int key_is_zero = 1;
     for (int i = 0; i < 32; i++) {
         if (EASYCRYPTO_KEY[i] != 0) {
             key_is_zero = 0;
             break;
         }
     }
     if (key_is_zero) {
         fprintf(stderr, "Error: Encryption key not set\n");
         return result;
     }
 
     // Generate random IV
     uint8_t iv[12];
     generate_random_bytes(iv, 12);
 
     // Allocate output: [algo_id(1)][iv(12)][ciphertext][tag(16)]
     size_t output_len = 1 + 12 + plaintext_len + 16;
     uint8_t *output = malloc(output_len);
     if (!output) {
         return result;
     }
 
     output[0] = (uint8_t)algo;
     memcpy(output + 1, iv, 12);
 
     uint8_t *ciphertext = output + 13;
     uint8_t *tag = output + 13 + plaintext_len;
 
     int status = -1;
 
     if (algo == AES_256_GCM) {
         if (!crypto_has_aesni || !crypto_has_pclmulqdq) {
             fprintf(stderr, "Error: CPU lacks AES-NI/PCLMULQDQ\n");
             free(output);
             return result;
         }
 
         aes256_gcm_context ctx;
         if (aes256_gcm_init(&ctx, EASYCRYPTO_KEY) == 0) {
             status = aes256_gcm_encrypt(&ctx, iv, 12, aad, aad_len,
                                        plaintext, plaintext_len,
                                        ciphertext, tag, 16);
         }
     } else if (algo == SERPENT_256_GCM) {
         if (!crypto_has_pclmulqdq) {
             fprintf(stderr, "Error: CPU lacks PCLMULQDQ\n");
             free(output);
             return result;
         }
 
         serpent_gcm_context ctx;
         if (serpent_gcm_init(&ctx, EASYCRYPTO_KEY) == 0) {
             status = serpent_gcm_encrypt(&ctx, iv, 12, aad, aad_len,
                                         plaintext, plaintext_len,
                                         ciphertext, tag, 16);
         }
     }
 
     if (status != 0) {
         free(output);
         return result;
     }
 
     result.data = output;
     result.length = output_len;
     result.success = 1;
 
     return result;
 }
 
 CryptoResult easycrypto_decrypt(const uint8_t *encrypted, size_t encrypted_len,
                                 const uint8_t *aad, size_t aad_len) {
     CryptoResult result = {NULL, 0, 0};
 
     if (!g_initialized) {
         easycrypto_init();
     }
 
     if (encrypted_len < 29) {
         fprintf(stderr, "Error: Data too short\n");
         return result;
     }
 
     CryptoAlgorithm algo = (CryptoAlgorithm)encrypted[0];
     const uint8_t *iv = encrypted + 1;
 
     size_t ct_len = encrypted_len - 29;
     const uint8_t *ciphertext = encrypted + 13;
     const uint8_t *tag = encrypted + 13 + ct_len;
 
     uint8_t *plaintext = malloc(ct_len);
     if (!plaintext) {
         return result;
     }
 
     int status = -1;
 
     if (algo == AES_256_GCM) {
         if (!crypto_has_aesni || !crypto_has_pclmulqdq) {
             fprintf(stderr, "Error: CPU lacks AES-NI/PCLMULQDQ\n");
             free(plaintext);
             return result;
         }
 
         aes256_gcm_context ctx;
         if (aes256_gcm_init(&ctx, EASYCRYPTO_KEY) == 0) {
             status = aes256_gcm_decrypt(&ctx, iv, 12, aad, aad_len,
                                        ciphertext, ct_len, tag, 16, plaintext);
         }
     } else if (algo == SERPENT_256_GCM) {
         if (!crypto_has_pclmulqdq) {
             fprintf(stderr, "Error: CPU lacks PCLMULQDQ\n");
             free(plaintext);
             return result;
         }
 
         serpent_gcm_context ctx;
         if (serpent_gcm_init(&ctx, EASYCRYPTO_KEY) == 0) {
             status = serpent_gcm_decrypt(&ctx, iv, 12, aad, aad_len,
                                         ciphertext, ct_len, tag, 16, plaintext);
         }
     }
 
     if (status != 0) {
         fprintf(stderr, "Error: Decryption failed\n");
         free(plaintext);
         return result;
     }
 
     result.data = plaintext;
     result.length = ct_len;
     result.success = 1;
 
     return result;
 }
 
 void easycrypto_free(CryptoResult *result) {
     if (result && result->data) {
         free(result->data);
         result->data = NULL;
         result->length = 0;
         result->success = 0;
     }
 }
 
 void easycrypto_print_hex(const char *label, const uint8_t *data, size_t len) {
     printf("%s: ", label);
     for (size_t i = 0; i < len; i++) {
         printf("%02x", data[i]);
     }
     printf("\n");
 }
 
 const char* easycrypto_algorithm_name(CryptoAlgorithm algo) {
     switch (algo) {
         case AES_256_GCM: return "AES-256-GCM";
         case SERPENT_256_GCM: return "Serpent-256-GCM";
         default: return "Unknown";
     }
 }