/* sakura1.c - Don Yang (uguu.org)
   Preprocess 1: Remove comments / inline functions

   02/08/01
                                                                           */

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

typedef unsigned int DWORD;
typedef unsigned char BYTE;

typedef struct
{
   DWORD state[4];
   DWORD size[2];
   BYTE block[64];

} MD5_CTX;

static DWORD Table[64];
static DWORD Reg[4], *a, *b, *c, *d;

static void RotateLeft(DWORD *x, DWORD n)
{
   *x = ((*x) << n) | ((*x) >> (32 - n));
}

static void FF(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd,
               DWORD x, DWORD s, DWORD ac)
{
   *pa += x + ac + ( ((*pb) & (*pc)) | ((~*pb) & (*pd)) );
   RotateLeft(pa, s);
   *pa += *pb;
}

static void GG(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd,
               DWORD x, DWORD s, DWORD ac)
{
   *pa += x + ac + ( ((*pb) & (*pd)) | ((*pc) & (~*pd)) );
   RotateLeft(pa, s);
   *pa += *pb;
}

static void HH(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd,
               DWORD x, DWORD s, DWORD ac)
{
   *pa += x + ac + ( (*pb) ^ (*pc) ^ (*pd) );
   RotateLeft(pa, s);
   *pa += *pb;
}

static void II(DWORD *pa, DWORD *pb, DWORD *pc, DWORD *pd,
               DWORD x, DWORD s, DWORD ac)
{
   *pa += x + ac + ( (*pc) ^ ((*pb) | (~*pd)) );
   RotateLeft(pa, s);
   *pa += *pb;
}

static void Encode(BYTE *output, DWORD *input, DWORD length)
{
   DWORD i, j;

   for(i = j = 0; j < length; i++, j += 4)
   {
      output[j] = (BYTE)(input[i] & 0xff);
      output[j + 1] = (BYTE)((input[i] >> 8) & 0xff);
      output[j + 2] = (BYTE)((input[i] >> 16) & 0xff);
      output[j + 3] = (BYTE)((input[i] >> 24) & 0xff);
   }
}

static void MD5Transform(DWORD *state, BYTE *block)
{
   DWORD x[16];
   DWORD i, j;

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

   for(i = j = 0; j < 64; i++, j += 4)
   {
      x[i] =
         ((DWORD)block[j]) |
         (((DWORD)block[j + 1]) << 8) |
         (((DWORD)block[j + 2]) << 16) |
         (((DWORD)block[j + 3]) << 24);
   }

   FF(a, b, c, d, x[ 0],  7, Table[0]);
   FF(d, a, b, c, x[ 1], 12, Table[1]);
   FF(c, d, a, b, x[ 2], 17, Table[2]);
   FF(b, c, d, a, x[ 3], 22, Table[3]);
   FF(a, b, c, d, x[ 4],  7, Table[4]);
   FF(d, a, b, c, x[ 5], 12, Table[5]);
   FF(c, d, a, b, x[ 6], 17, Table[6]);
   FF(b, c, d, a, x[ 7], 22, Table[7]);
   FF(a, b, c, d, x[ 8],  7, Table[8]);
   FF(d, a, b, c, x[ 9], 12, Table[9]);
   FF(c, d, a, b, x[10], 17, Table[10]);
   FF(b, c, d, a, x[11], 22, Table[11]);
   FF(a, b, c, d, x[12],  7, Table[12]);
   FF(d, a, b, c, x[13], 12, Table[13]);
   FF(c, d, a, b, x[14], 17, Table[14]);
   FF(b, c, d, a, x[15], 22, Table[15]);

   GG(a, b, c, d, x[ 1],  5, Table[16]);
   GG(d, a, b, c, x[ 6],  9, Table[17]);
   GG(c, d, a, b, x[11], 14, Table[18]);
   GG(b, c, d, a, x[ 0], 20, Table[19]);
   GG(a, b, c, d, x[ 5],  5, Table[20]);
   GG(d, a, b, c, x[10],  9, Table[21]);
   GG(c, d, a, b, x[15], 14, Table[22]);
   GG(b, c, d, a, x[ 4], 20, Table[23]);
   GG(a, b, c, d, x[ 9],  5, Table[24]);
   GG(d, a, b, c, x[14],  9, Table[25]);
   GG(c, d, a, b, x[ 3], 14, Table[26]);
   GG(b, c, d, a, x[ 8], 20, Table[27]);
   GG(a, b, c, d, x[13],  5, Table[28]);
   GG(d, a, b, c, x[ 2],  9, Table[29]);
   GG(c, d, a, b, x[ 7], 14, Table[30]);
   GG(b, c, d, a, x[12], 20, Table[31]);

   HH(a, b, c, d, x[ 5],  4, Table[32]);
   HH(d, a, b, c, x[ 8], 11, Table[33]);
   HH(c, d, a, b, x[11], 16, Table[34]);
   HH(b, c, d, a, x[14], 23, Table[35]);
   HH(a, b, c, d, x[ 1],  4, Table[36]);
   HH(d, a, b, c, x[ 4], 11, Table[37]);
   HH(c, d, a, b, x[ 7], 16, Table[38]);
   HH(b, c, d, a, x[10], 23, Table[39]);
   HH(a, b, c, d, x[13],  4, Table[40]);
   HH(d, a, b, c, x[ 0], 11, Table[41]);
   HH(c, d, a, b, x[ 3], 16, Table[42]);
   HH(b, c, d, a, x[ 6], 23, Table[43]);
   HH(a, b, c, d, x[ 9],  4, Table[44]);
   HH(d, a, b, c, x[12], 11, Table[45]);
   HH(c, d, a, b, x[15], 16, Table[46]);
   HH(b, c, d, a, x[ 2], 23, Table[47]);

   II(a, b, c, d, x[ 0],  6, Table[48]);
   II(d, a, b, c, x[ 7], 10, Table[49]);
   II(c, d, a, b, x[14], 15, Table[50]);
   II(b, c, d, a, x[ 5], 21, Table[51]);
   II(a, b, c, d, x[12],  6, Table[52]);
   II(d, a, b, c, x[ 3], 10, Table[53]);
   II(c, d, a, b, x[10], 15, Table[54]);
   II(b, c, d, a, x[ 1], 21, Table[55]);
   II(a, b, c, d, x[ 8],  6, Table[56]);
   II(d, a, b, c, x[15], 10, Table[57]);
   II(c, d, a, b, x[ 6], 15, Table[58]);
   II(b, c, d, a, x[13], 21, Table[59]);
   II(a, b, c, d, x[ 4],  6, Table[60]);
   II(d, a, b, c, x[11], 10, Table[61]);
   II(c, d, a, b, x[ 2], 15, Table[62]);
   II(b, c, d, a, x[ 9], 21, Table[63]);

   state[0] += *a;
   state[1] += *b;
   state[2] += *c;
   state[3] += *d;
}

static void MD5Update(MD5_CTX *context, BYTE *input, DWORD length)
{
   DWORD i, index, plength;

   index = ((context->size[0] >> 3) & 0x3f);
   if( (context->size[0] += (length << 3)) < (length << 3) )
      context->size[1]++;
   context->size[1] += (length >> 29);

   plength = 64 - index;

   if( length >= plength )
   {
      memcpy(&context->block[index], input, plength);
      MD5Transform(context->state, context->block);

      for(i = plength; i + 63 < length; i += 64)
         MD5Transform(context->state, input + i);
      index = 0;
   }
   else
   {
      i = 0;
   }

   memcpy(&context->block[index], input + i, length - i);
}

int main(int argc, char **argv)
{
   FILE *infile;
   MD5_CTX context;
   DWORD length, i;
   BYTE buffer[1024], digest[16];
   static BYTE Padding[64] = {0x80,
         0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0};
   BYTE bits[8];
   DWORD index, padlength;

   if( argc < 2 )
   {
      printf("%s <infile>\n", argv[0]);
      return 0;
   }

   if( (infile = fopen(argv[1], "rb")) == NULL )
   {
      printf("Can not open %s\n", argv[1]);
      return 1;
   }

   for(i = 1; i <= 64; i++)
      Table[i - 1] = (DWORD)(4294967296 * fabs(sin((double)i)));

   a = &Reg[0];
   b = &Reg[1];
   c = &Reg[2];
   d = &Reg[3];

   context.size[0] = context.size[1] = 0;
   context.state[0] = 0x67452301;
   context.state[1] = 0xefcdab89;
   context.state[2] = 0x98badcfe;
   context.state[3] = 0x10325476;

   while( (length = fread(buffer, 1, 1024, infile)) != 0 )
      MD5Update(&context, buffer, length);

   Encode(bits, context.size, 8);

   index = ((context.size[0] >> 3) & 0x3f);
   padlength = (index < 56) ? (56 - index) : (120 - index);
   MD5Update(&context, Padding, padlength);
   MD5Update(&context, bits, 8);

   Encode(digest, context.state, 16);

   for(i = 0; i < 16; i++)
      printf("%02x", (DWORD)digest[i]);
   putchar('\n');

   fclose(infile);
   return 0;
}