luajitos

example_hash.c (8506B)

---

 /*
  * Unified Hash API Example
  * Demonstrates usage of SHA-256, SHA-512, SHA-1, MD5, and CRC32
  */
 
 #include "hash.h"
 #include <stdio.h>
 #include <string.h>
 
 int main(void) {
     printf("╔═══════════════════════════════════════════╗\n");
     printf("║  Unified Hash API - Comprehensive Demo   ║\n");
     printf("╚═══════════════════════════════════════════╝\n\n");
 
     // Test data
     const char *test_strings[] = {
         "",
         "abc",
         "The quick brown fox jumps over the lazy dog",
         "Hello, World!"
     };
 
     // Test all algorithms
     for (int i = 0; i < 4; i++) {
         const char *str = test_strings[i];
         printf("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
         printf("Input: \"%s\"\n", str);
         printf("Length: %zu bytes\n", strlen(str));
         printf("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
 
         // SHA-256
         HashResult sha256_result = hash_compute(HASH_SHA256, (uint8_t*)str, strlen(str));
         hash_print("SHA-256", &sha256_result);
         hash_free(&sha256_result);
 
         // SHA-512
         HashResult sha512_result = hash_compute(HASH_SHA512, (uint8_t*)str, strlen(str));
         hash_print("SHA-512", &sha512_result);
         hash_free(&sha512_result);
 
         // SHA-1
         HashResult sha1_result = hash_compute(HASH_SHA1, (uint8_t*)str, strlen(str));
         hash_print("SHA-1  ", &sha1_result);
         hash_free(&sha1_result);
 
         // MD5
         HashResult md5_result = hash_compute(HASH_MD5, (uint8_t*)str, strlen(str));
         hash_print("MD5    ", &md5_result);
         hash_free(&md5_result);
 
         // CRC32
         HashResult crc32_result = hash_compute(HASH_CRC32, (uint8_t*)str, strlen(str));
         hash_print("CRC32  ", &crc32_result);
         hash_free(&crc32_result);
 
         printf("\n");
     }
 
     // Demonstrate macro usage
     printf("═════════════════════════════════════════════\n");
     printf("  Macro Usage Example\n");
     printf("═════════════════════════════════════════════\n\n");
 
     const char *password = "MySecretPassword123!";
     printf("Hashing password: \"%s\"\n\n", password);
 
     HashResult h1 = HASH(HASH_SHA256, password);
     hash_print("SHA-256", &h1);
 
     HashResult h2 = hash_sha512_str(password);
     hash_print("SHA-512", &h2);
 
     hash_free(&h1);
     hash_free(&h2);
 
     // Demonstrate hex conversion
     printf("\n═════════════════════════════════════════════\n");
     printf("  Hex String Conversion\n");
     printf("═════════════════════════════════════════════\n\n");
 
     HashResult h3 = hash_md5_str("test");
     char *hex = hash_to_hex(&h3);
     if (hex) {
         printf("MD5 of \"test\" as string: %s\n", hex);
         free(hex);
     }
     hash_free(&h3);
 
     // Demonstrate hash comparison
     printf("\n═════════════════════════════════════════════\n");
     printf("  Hash Comparison\n");
     printf("═════════════════════════════════════════════\n\n");
 
     HashResult h4 = hash_sha256_str("hello");
     HashResult h5 = hash_sha256_str("hello");
     HashResult h6 = hash_sha256_str("world");
 
     printf("Comparing hashes:\n");
     printf("  SHA-256(\"hello\") == SHA-256(\"hello\"): %s\n",
            hash_equals(&h4, &h5) ? "✓ Equal" : "✗ Not equal");
     printf("  SHA-256(\"hello\") == SHA-256(\"world\"): %s\n",
            hash_equals(&h4, &h6) ? "✓ Equal" : "✗ Not equal");
 
     hash_free(&h4);
     hash_free(&h5);
     hash_free(&h6);
 
     // Security warnings
     printf("\n═════════════════════════════════════════════\n");
     printf("  Security Notes\n");
     printf("═════════════════════════════════════════════\n\n");
 
     printf("✓ SHA-256: Recommended for most cryptographic uses\n");
     printf("✓ SHA-512: Recommended for maximum security\n");
     printf("⚠ SHA-1:   Cryptographically broken, use only for compatibility\n");
     printf("⚠ MD5:     Cryptographically broken, use only for checksums\n");
     printf("✓ CRC32:   Good for error detection, NOT for security\n");
 
     printf("\n═════════════════════════════════════════════\n");
     printf("  Performance Tips\n");
     printf("═════════════════════════════════════════════\n\n");
 
     printf("• SHA-256 uses hardware acceleration (SHA extensions) when available\n");
     printf("• CRC32 uses hardware acceleration (SSE 4.2) when available\n");
     printf("• SHA-512 is optimized for 64-bit processors\n");
     printf("• Use CRC32 for checksums, SHA-256/512 for security\n");
 
     printf("\n═════════════════════════════════════════════\n");
     printf("  Common Use Cases\n");
     printf("═════════════════════════════════════════════\n\n");
 
     // File integrity check simulation
     const char *file_data = "This is the content of a file...";
     printf("Use Case 1: File Integrity Verification\n");
     printf("----------------------------------------\n");
     HashResult file_hash = hash_sha256_str(file_data);
     printf("Original file hash: ");
     char *file_hex = hash_to_hex(&file_hash);
     if (file_hex) {
         printf("%s\n", file_hex);
         free(file_hex);
     }
     printf("→ Store this hash to verify file integrity later\n\n");
     hash_free(&file_hash);
 
     // Password storage simulation (simplified)
     printf("Use Case 2: Password Hashing (simplified)\n");
     printf("------------------------------------------\n");
     const char *user_password = "user_password_123";
     HashResult pwd_hash = hash_sha512_str(user_password);
     printf("Password hash to store: ");
     char *pwd_hex = hash_to_hex(&pwd_hash);
     if (pwd_hex) {
         printf("%s\n", pwd_hex);
         printf("→ Never store plaintext passwords!\n");
         printf("→ In production, use proper password hashing (bcrypt, argon2)\n\n");
         free(pwd_hex);
     }
     hash_free(&pwd_hash);
 
     // Data deduplication simulation
     printf("Use Case 3: Data Deduplication\n");
     printf("--------------------------------\n");
     const char *chunk1 = "Data chunk 1";
     const char *chunk2 = "Data chunk 2";
     const char *chunk3 = "Data chunk 1"; // Duplicate of chunk1
 
     HashResult c1 = hash_sha256_str(chunk1);
     HashResult c2 = hash_sha256_str(chunk2);
     HashResult c3 = hash_sha256_str(chunk3);
 
     printf("Chunk 1 hash: ");
     char *c1_hex = hash_to_hex(&c1);
     if (c1_hex) { printf("%s\n", c1_hex); free(c1_hex); }
 
     printf("Chunk 2 hash: ");
     char *c2_hex = hash_to_hex(&c2);
     if (c2_hex) { printf("%s\n", c2_hex); free(c2_hex); }
 
     printf("Chunk 3 hash: ");
     char *c3_hex = hash_to_hex(&c3);
     if (c3_hex) { printf("%s\n", c3_hex); free(c3_hex); }
 
     printf("→ Chunk 1 and 3 have same hash (duplicates detected)\n");
 
     hash_free(&c1);
     hash_free(&c2);
     hash_free(&c3);
 
     printf("\n═════════════════════════════════════════════\n");
     printf("  Demo Complete!\n");
     printf("═════════════════════════════════════════════\n");
 
     return 0;
 }