luajitos

SHA1.c (4902B)

---

 /*
  * SHA-1 Implementation
  * Note: SHA-1 is cryptographically broken, use for compatibility only
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
 
 // SHA-1 context
 typedef struct {
     uint32_t state[5];
     uint64_t count;
     uint8_t buffer[64];
 } sha1_context;
 
 // Rotate left
 #define ROTL(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 
 // SHA-1 functions
 #define F1(b, c, d) (((b) & (c)) | (~(b) & (d)))
 #define F2(b, c, d) ((b) ^ (c) ^ (d))
 #define F3(b, c, d) (((b) & (c)) | ((b) & (d)) | ((c) & (d)))
 #define F4(b, c, d) ((b) ^ (c) ^ (d))
 
 // SHA-1 transform
 static void sha1_transform(uint32_t state[5], const uint8_t block[64]) {
     uint32_t W[80];
     uint32_t a, b, c, d, e, temp;
     int i;
 
     // Prepare message schedule
     for (i = 0; i < 16; i++) {
         W[i] = ((uint32_t)block[i * 4] << 24) |
                ((uint32_t)block[i * 4 + 1] << 16) |
                ((uint32_t)block[i * 4 + 2] << 8) |
                ((uint32_t)block[i * 4 + 3]);
     }
 
     for (i = 16; i < 80; i++) {
         W[i] = ROTL(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
     }
 
     // Initialize working variables
     a = state[0];
     b = state[1];
     c = state[2];
     d = state[3];
     e = state[4];
 
     // Main loop - Round 1
     for (i = 0; i < 20; i++) {
         temp = ROTL(a, 5) + F1(b, c, d) + e + W[i] + 0x5A827999;
         e = d; d = c; c = ROTL(b, 30); b = a; a = temp;
     }
 
     // Round 2
     for (i = 20; i < 40; i++) {
         temp = ROTL(a, 5) + F2(b, c, d) + e + W[i] + 0x6ED9EBA1;
         e = d; d = c; c = ROTL(b, 30); b = a; a = temp;
     }
 
     // Round 3
     for (i = 40; i < 60; i++) {
         temp = ROTL(a, 5) + F3(b, c, d) + e + W[i] + 0x8F1BBCDC;
         e = d; d = c; c = ROTL(b, 30); b = a; a = temp;
     }
 
     // Round 4
     for (i = 60; i < 80; i++) {
         temp = ROTL(a, 5) + F4(b, c, d) + e + W[i] + 0xCA62C1D6;
         e = d; d = c; c = ROTL(b, 30); b = a; a = temp;
     }
 
     // Update state
     state[0] += a;
     state[1] += b;
     state[2] += c;
     state[3] += d;
     state[4] += e;
 }
 
 // Initialize SHA-1 context
 void sha1_init(sha1_context *ctx) {
     ctx->state[0] = 0x67452301;
     ctx->state[1] = 0xEFCDAB89;
     ctx->state[2] = 0x98BADCFE;
     ctx->state[3] = 0x10325476;
     ctx->state[4] = 0xC3D2E1F0;
     ctx->count = 0;
 }
 
 // Update SHA-1 with data
 void sha1_update(sha1_context *ctx, const uint8_t *data, size_t len) {
     size_t i, index, part_len;
 
     index = (size_t)(ctx->count & 0x3F);
     ctx->count += len;
     part_len = 64 - index;
 
     if (len >= part_len) {
         memcpy(&ctx->buffer[index], data, part_len);
         sha1_transform(ctx->state, ctx->buffer);
 
         for (i = part_len; i + 63 < len; i += 64) {
             sha1_transform(ctx->state, &data[i]);
         }
         index = 0;
     } else {
         i = 0;
     }
 
     memcpy(&ctx->buffer[index], &data[i], len - i);
 }
 
 // Finalize SHA-1 and produce digest
 void sha1_final(sha1_context *ctx, uint8_t digest[20]) {
     uint8_t bits[8];
     size_t index, pad_len;
     uint64_t bit_count = ctx->count * 8;
 
     // Encode bit count
     for (int i = 0; i < 8; i++) {
         bits[7 - i] = (uint8_t)(bit_count >> (i * 8));
     }
 
     // Pad
     index = (size_t)(ctx->count & 0x3F);
     pad_len = (index < 56) ? (56 - index) : (120 - index);
 
     uint8_t padding[64];
     padding[0] = 0x80;
     memset(padding + 1, 0, pad_len - 1);
 
     sha1_update(ctx, padding, pad_len);
     sha1_update(ctx, bits, 8);
 
     // Store digest
     for (int i = 0; i < 5; i++) {
         digest[i * 4] = (uint8_t)(ctx->state[i] >> 24);
         digest[i * 4 + 1] = (uint8_t)(ctx->state[i] >> 16);
         digest[i * 4 + 2] = (uint8_t)(ctx->state[i] >> 8);
         digest[i * 4 + 3] = (uint8_t)(ctx->state[i]);
     }
 }
 
 // One-shot SHA-1
 void sha1(const uint8_t *data, size_t len, uint8_t digest[20]) {
     sha1_context ctx;
     sha1_init(&ctx);
     sha1_update(&ctx, data, len);
     sha1_final(&ctx, digest);
 }
 
 // Test program
 #ifndef LIB_MODE
 int main(void) {
     printf("SHA-1 Implementation\n");
     printf("====================\n");
     printf("WARNING: SHA-1 is cryptographically broken. Use for compatibility only!\n\n");
 
     // Test vectors
     const char *test1 = "abc";
     const char *test2 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
 
     uint8_t digest[20];
 
     // Test 1
     printf("Test 1: \"%s\"\n", test1);
     sha1((uint8_t*)test1, strlen(test1), digest);
     printf("SHA-1: ");
     for (int i = 0; i < 20; i++) printf("%02x", digest[i]);
     printf("\n");
     printf("Expected: a9993e364706816aba3e25717850c26c9cd0d89d\n\n");
 
     // Test 2
     printf("Test 2: \"%s\"\n", test2);
     sha1((uint8_t*)test2, strlen(test2), digest);
     printf("SHA-1: ");
     for (int i = 0; i < 20; i++) printf("%02x", digest[i]);
     printf("\n");
     printf("Expected: 84983e441c3bd26ebaae4aa1f95129e5e54670f1\n\n");
 
     return 0;
 }
 #endif