/* bell0.c - Don Yang (uguu.org)

   03/15/01
                                                                           */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef unsigned long uint32;

typedef struct SHA1Context
{
   uint32 state[5];
   uint32 count[2];
   unsigned char buffer[64];

} SHA1_CTX;

typedef union
{
   unsigned char c[64];
   uint32 l[16];

} CHAR64LONG16;

SHA1_CTX ctx;
CHAR64LONG16 *block;

#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))

#ifndef WORDS_BIGENDIAN
#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
    |(rol(block->l[i],8)&0x00FF00FF))
#else
#define blk0(i) block->l[i]
#endif

#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
    ^block->l[(i+2)&15]^block->l[i&15],1))

#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);


void SHA1Transform(uint32 state[5], unsigned char buffer[64])
{
   uint32 a, b, c, d, e;

   block = (CHAR64LONG16*)buffer;

   a = state[0];
   b = state[1];
   c = state[2];
   d = state[3];
   e = state[4];

   R0(a, b, c, d, e, 0);
   R0(e, a, b, c, d, 1);
   R0(d, e, a, b, c, 2);
   R0(c, d, e, a, b, 3);
   R0(b, c, d, e, a, 4);
   R0(a, b, c, d, e, 5);
   R0(e, a, b, c, d, 6);
   R0(d, e, a, b, c, 7);
   R0(c, d, e, a, b, 8);
   R0(b, c, d, e, a, 9);
   R0(a, b, c, d, e, 10);
   R0(e, a, b, c, d, 11);
   R0(d, e, a, b, c, 12);
   R0(c, d, e, a, b, 13);
   R0(b, c, d, e, a, 14);
   R0(a, b, c, d, e, 15);
   R1(e, a, b, c, d, 16);
   R1(d, e, a, b, c, 17);
   R1(c, d, e, a, b, 18);
   R1(b, c, d, e, a, 19);
   R2(a, b, c, d, e, 20);
   R2(e, a, b, c, d, 21);
   R2(d, e, a, b, c, 22);
   R2(c, d, e, a, b, 23);
   R2(b, c, d, e, a, 24);
   R2(a, b, c, d, e, 25);
   R2(e, a, b, c, d, 26);
   R2(d, e, a, b, c, 27);
   R2(c, d, e, a, b, 28);
   R2(b, c, d, e, a, 29);
   R2(a, b, c, d, e, 30);
   R2(e, a, b, c, d, 31);
   R2(d, e, a, b, c, 32);
   R2(c, d, e, a, b, 33);
   R2(b, c, d, e, a, 34);
   R2(a, b, c, d, e, 35);
   R2(e, a, b, c, d, 36);
   R2(d, e, a, b, c, 37);
   R2(c, d, e, a, b, 38);
   R2(b, c, d, e, a, 39);
   R3(a, b, c, d, e, 40);
   R3(e, a, b, c, d, 41);
   R3(d, e, a, b, c, 42);
   R3(c, d, e, a, b, 43);
   R3(b, c, d, e, a, 44);
   R3(a, b, c, d, e, 45);
   R3(e, a, b, c, d, 46);
   R3(d, e, a, b, c, 47);
   R3(c, d, e, a, b, 48);
   R3(b, c, d, e, a, 49);
   R3(a, b, c, d, e, 50);
   R3(e, a, b, c, d, 51);
   R3(d, e, a, b, c, 52);
   R3(c, d, e, a, b, 53);
   R3(b, c, d, e, a, 54);
   R3(a, b, c, d, e, 55);
   R3(e, a, b, c, d, 56);
   R3(d, e, a, b, c, 57);
   R3(c, d, e, a, b, 58);
   R3(b, c, d, e, a, 59);
   R4(a, b, c, d, e, 60);
   R4(e, a, b, c, d, 61);
   R4(d, e, a, b, c, 62);
   R4(c, d, e, a, b, 63);
   R4(b, c, d, e, a, 64);
   R4(a, b, c, d, e, 65);
   R4(e, a, b, c, d, 66);
   R4(d, e, a, b, c, 67);
   R4(c, d, e, a, b, 68);
   R4(b, c, d, e, a, 69);
   R4(a, b, c, d, e, 70);
   R4(e, a, b, c, d, 71);
   R4(d, e, a, b, c, 72);
   R4(c, d, e, a, b, 73);
   R4(b, c, d, e, a, 74);
   R4(a, b, c, d, e, 75);
   R4(e, a, b, c, d, 76);
   R4(d, e, a, b, c, 77);
   R4(c, d, e, a, b, 78);
   R4(b, c, d, e, a, 79);

   state[0] += a;
   state[1] += b;
   state[2] += c;
   state[3] += d;
   state[4] += e;

   a = b = c = d = e = 0;
}

void SHA1Init(void)
{
   ctx.state[0] = 0x67452301;
   ctx.state[1] = 0xefcdab89;
   ctx.state[2] = 0x98badcfe;
   ctx.state[3] = 0x10325476;
   ctx.state[4] = 0xc3d2e1f0;
   ctx.count[0] = ctx.count[1] = 0;
}

void SHA1Update(unsigned const char *data, unsigned int len)
{
   unsigned int i, j;

   j = (ctx.count[0] >> 3) & 63;
   if( (ctx.count[0] += len << 3) < (len << 3) )
      ctx.count[1]++;
   ctx.count[1] += (len >> 29);
   if( (j + len) > 63 )
   {
      memmove(&ctx.buffer[j], data, (i = 64 - j));
      SHA1Transform(ctx.state, ctx.buffer);
      for(; i + 63 < len; i += 64)
         SHA1Transform(ctx.state, (unsigned char*)&data[i]);
      j = 0;
   }
   else
   {
      i = 0;
   }
   memmove(&ctx.buffer[j], &data[i], len - i);
}

void SHA1Final(unsigned char digest[20])
{
   unsigned char finalcount[8];
   uint32 i;

   for(i = 0; i < 8; i++)
   {
      finalcount[i] = (unsigned char)
         ((ctx.count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255);
   }
   SHA1Update((unsigned char*) "\200", 1);
   while( (ctx.count[0] & 504) != 448 )
      SHA1Update((unsigned char*) "\0", 1);
   SHA1Update(finalcount, 8);
   for(i = 0; i < 20; i++)
   {
      digest[i] = (unsigned char)
         ((ctx.state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
   }
}

int main(int argc, char **argv)
{
   unsigned char buffer[16384];
   FILE *infile;
   int i;

   if( argc < 2 )
      return 1;
   if( (infile = fopen(argv[1], "rb")) == NULL )
      return 1;

   SHA1Init();
   while( !feof(infile) )
   {
      i = fread(buffer, 1, 16384, infile);
      SHA1Update(buffer, i);
   }
   SHA1Final(buffer);
   for(i = 0; i < 20; i += 4)
   {
      printf("%02x%02x%02x%02x ",
         buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3]);
   }
   putchar('\n');

   fclose(infile);
   return 0;
}