juegos

sha1.c (2517B)

---

 /* sha1.c - SHA-1 en un solo bloque de memoria, y base64. */
 #include <string.h>
 #include "sha1.h"
 
 #define ROL(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 
 static void block(uint32_t h[5], const uint8_t *p)
 {
     uint32_t w[80];
     for (int i = 0; i < 16; i++)
         w[i] = (uint32_t)p[4 * i] << 24 | (uint32_t)p[4 * i + 1] << 16 | (uint32_t)p[4 * i + 2] << 8 | p[4 * i + 3];
     for (int i = 16; i < 80; i++) w[i] = ROL(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
     uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
     for (int i = 0; i < 80; i++) {
         uint32_t f, k;
         if (i < 20) { f = (b & c) | (~b & d); k = 0x5a827999; }
         else if (i < 40) { f = b ^ c ^ d; k = 0x6ed9eba1; }
         else if (i < 60) { f = (b & c) | (b & d) | (c & d); k = 0x8f1bbcdc; }
         else { f = b ^ c ^ d; k = 0xca62c1d6; }
         uint32_t t = ROL(a, 5) + f + e + k + w[i];
         e = d; d = c; c = ROL(b, 30); b = a; a = t;
     }
     h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e;
 }
 
 void sha1(const void *data, size_t len, uint8_t out[20])
 {
     uint32_t h[5] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
     const uint8_t *p = data;
     size_t i = 0;
     for (; i + 64 <= len; i += 64) block(h, p + i);
     uint8_t tail[128];
     size_t rest = len - i;
     memcpy(tail, p + i, rest);
     tail[rest++] = 0x80;
     size_t total = rest <= 56 ? 64 : 128;
     memset(tail + rest, 0, total - rest);
     uint64_t bits = (uint64_t)len * 8;
     for (int k = 0; k < 8; k++) tail[total - 1 - k] = (uint8_t)(bits >> (8 * k));
     block(h, tail);
     if (total == 128) block(h, tail + 64);
     for (int k = 0; k < 5; k++) {
         out[4 * k] = (uint8_t)(h[k] >> 24); out[4 * k + 1] = (uint8_t)(h[k] >> 16);
         out[4 * k + 2] = (uint8_t)(h[k] >> 8); out[4 * k + 3] = (uint8_t)h[k];
     }
 }
 
 int base64_encode(const void *data, size_t n, char *out, size_t cap)
 {
     static const char T[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     size_t need = (n + 2) / 3 * 4;
     if (need + 1 > cap) return -1;
     const uint8_t *p = data;
     size_t o = 0;
     for (size_t i = 0; i < n; i += 3) {
         uint32_t v = (uint32_t)p[i] << 16;
         if (i + 1 < n) v |= (uint32_t)p[i + 1] << 8;
         if (i + 2 < n) v |= p[i + 2];
         out[o++] = T[(v >> 18) & 63];
         out[o++] = T[(v >> 12) & 63];
         out[o++] = i + 1 < n ? T[(v >> 6) & 63] : '=';
         out[o++] = i + 2 < n ? T[v & 63] : '=';
     }
     out[o] = 0;
     return (int)o;
 }