/* see RFC 1321, R. Rivest for further discussion.

                     The MD5 Message-Digest Algorithm
                     
   transcribed to Java by Burton Rosenberg, 
   Copyright (C) 1996 Burton Rosenberg, ALl rights reserced.
   
   License to copy and use this software is granted provided
   that this copyright appears intact in the software.
   Software is proved "as is" without express or implied warranty
   of any kind. 

      October 26, 1996 1:16 PM.
      October 27, 1996 8:18 PM. (1321 test suite correct)
      October 28, 1996 10:07 AM.       
*/

/*
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.

License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.

License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.

RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
 
 
/* GLOBAL.H - RSAREF types and constants
 */

/* POINTER defines a generic pointer type */
// typedef unsigned char *POINTER;

/* UINT2 defines a two byte word */
// typedef unsigned short int UINT2;

/* UINT4 defines a four byte word */
// typedef unsigned long int UINT4;

//package popper ;

class Md5 extends Object {
 
  /* MD5 context: typedef struct{} MD5_CTX ; */
  
  static final boolean DEBUG = false ;

  int [] state = { 0x67452301, 0xefcdab89, 
      0x98badcfe, 0x10325476 } ;  /* state (ABCD) */
  long count = 0 ; /* number of bits, modulo 2^64 (lsb first) */
  byte [] buffer = new byte[64] ;  /* input buffer */
     
  /* Constants for MD5Transform routine. */

    static final int S11=7  ;
    static final int S12=12 ;
    static final int S13=17 ;
    static final int S14=22 ;
    static final int S21=5  ;
    static final int S22=9  ;
    static final int S23=14 ;
    static final int S24=20 ;
    static final int S31=4  ;
    static final int S32=11 ;
    static final int S33=16 ;
    static final int S34=23 ;
    static final int S41=6  ;
    static final int S42=10 ;
    static final int S43=15 ;
    static final int S44=21 ;
    
    static final byte [] PADDING = {
    (byte)0x80, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0,
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0,
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, 
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0,
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0,
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0,
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0,
    (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0
    } ;

   /* F, G, H and I are basic MD5 functions. */
   private int F( int x, int y, int z ) {
      return (((x) & (y)) | ((~x) & (z))) ;
   } 
   private int G( int x, int y, int z ) { 
      return (((x) & (z)) | ((y) & (~z))) ;
   }
   private int H( int x, int y, int z ) {
      return ((x) ^ (y) ^ (z)) ;
   }
   private int I( int x, int y, int z ) {
      return ((y) ^ ((x) | (~z))) ;
   }

   /* ROTATE_LEFT rotates x left n bits. */
   private int ROTATE_LEFT( int x, int n) {
      return (((x) << (n)) | ((x) >>> (32-(n)))) ;
   }

   /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
   Rotation is separate from addition to prevent recomputation. */
  
   private int FF( int a, int b, int c, int d, int x, int s, int ac) {
      a += F ((b), (c), (d)) + (x) + (ac);
      a = ROTATE_LEFT ((a), (s));
      a += (b);
      return a ;
   }
   private int GG( int a, int b, int c, int d, int x, int s, int ac) {
      a += G ((b), (c), (d)) + (x) + (ac);
      a = ROTATE_LEFT ((a), (s));
      a += (b);
      return a ;
   }
   private int HH( int a, int b, int c, int d, int x, int s, int ac) {
      a += H ((b), (c), (d)) + (x) + (ac);
      a = ROTATE_LEFT ((a), (s));
      a += (b);
      return a ;
   }
   private int II( int a, int b, int c, int d, int x, int s, int ac) {
      a += I ((b), (c), (d)) + (x) + (ac);
      a = ROTATE_LEFT ((a), (s));
      a += (b);
      return a ;
   }
 
   /* MD5 initialization. 
      Begins an MD5 operation, writing a new context.*/
   public void MD5Init () {
      count = 0; 
      /* Load magic initialization constants.*/
      state[0] = 0x67452301;
      state[1] = 0xefcdab89;
      state[2] = 0x98badcfe;
      state[3] = 0x10325476;
   }

   /* MD5 block update operation. 
      Continues an MD5 message-digest operation, processing 
      another message block, and updating the context. */ 
      
   public void MD5Update ( String input )
   {
      int i, index, partLen ;
      int inputLen = input.length() ;
      
      if (DEBUG)
         System.out.println(
         "MD5Update entered: input = " + input + " inputLen = " + inputLen ) ;
      
      /* Compute number of bytes mod 64 */
      index = (int)(count >>> 3) & 0x3F ;
      partLen = 64 - index ;

      /* Update number of bits */
      count += ((long)inputLen)<<3 ;

     /* Transform as many times as possible. */
     if (inputLen >= partLen)
     {
        //MD5_memcpy((POINTER)&buffer[index], (POINTER)input, partLen);
        for ( int j=0; j<partLen; j++ )
           buffer[index++] = (byte) input.charAt(j) ;
        MD5Transform (state, buffer) ;
        
        i = partLen ;
        while ( i + 63 < inputLen ) {
           for ( int j=0; j<64; j++ )
              buffer[j] = (byte) input.charAt(i++) ;
           MD5Transform (state, buffer) ;
        }
        
        index = 0 ;
      }
      else i = 0 ;

     /* Buffer remaining input */
     // MD5_memcpy ((POINTER)&context->buffer[index], 
     //             (POINTER)&input[i], inputLen-i);
     for ( int j = i ; j < inputLen; j++ ) 
        buffer[index++] = (byte) input.charAt(j) ;
 
     if (DEBUG) {
        System.out.println("MD5Update exiting: buffer is:") ;
        printBlock( buffer, 64 ) ;
     }

   }

  public void MD5Update( byte [] ba, int len ) {
     MD5Update( new String( ba, 0, 0, len ) ) ;
  }

   /* MD5 finalization. Ends an MD5 message-digest operation, writing the
  the message digest and zeroizing the context. */
  
  public void MD5Final ( byte [] digest /*16*/ )
  {
     byte [] bits = new byte[8] ;
     int index, padLen;
     int memset ;

     /* Save number of bits */
     Encode (bits, count) ;
  
     /* Pad out to 56 mod 64.*/
     index = (int) ((count >>> 3) & 0x3f) ;
     padLen = (index < 56) ? (56 - index) : (120 - index) ;
     MD5Update ( PADDING, padLen ) ;
     
     /* Append length (before padding) */
     MD5Update ( bits, 8 ) ;

     /* Store state in digest */
     Encode (digest, state, 16) ;

     /* Zeroize sensitive information.*/
     // MD5_memset ((POINTER)context, 0, sizeof (*context));
     for ( memset=0; memset<state.length; memset++) state[memset] = 0 ;
     for ( memset=0; memset<buffer.length; memset++ ) buffer[memset] = 0 ;
     count = 0 ;

   }
   
   public void MD5Final( StringBuffer sb )
   {
      byte [] digest = new byte[16] ;
      MD5Final( digest ) ;
      /* convert digest to hexidecimal */
	  for ( int i=0; i<16; i++ ) {
	     sb.append(hexdec[(digest[i]>>>4) & 0x0f]) ;
	     sb.append(hexdec[digest[i] & 0x0f]) ;   
	  }
   }

   public String MD5Digest( String s ) {
      StringBuffer b = new StringBuffer(32) ;
      MD5Update( s ) ;
      MD5Final ( b ) ;
      return b.toString() ;
   }

   public String MD5Digest() {
      return MD5Digest( "" ) ;
   }

   /* MD5 basic transformation. 
      Transforms state based on block. */

   private void MD5Transform( int [] state /* 4 */, byte [] block )
   {
      int a = state[0], b = state[1], c = state[2], d = state[3] ;
      int [] x = new int[16] ;
      int memset ;
      
      if (DEBUG) {
         System.out.println("MD5Transform entered:") ;
         printState(state,4) ;
         printBlock(block,64) ;
      }
     
      Decode (x, block, 64);
	
	  /* Round 1 */
	  a = FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
	  d = FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
	  c = FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
	  b = FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
	  a = FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
	  d = FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
	  c = FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
	  b = FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
	  a = FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
	  d = FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
	  c = FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
	  b = FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
	  a = FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
	  d = FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
	  c = FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
	  b = FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
	
	 /* Round 2 */
	  a = GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
	  d = GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
	  c = GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
	  b = GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
	  a = GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
	  d = GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
	  c = GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
	  b = GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
	  a = GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
	  d = GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
	  c = GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
	  b = GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
	  a = GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
	  d = GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
	  c = GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
	  b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
	
	  /* Round 3 */
	  a = HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
	  d = HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
	  c = HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
	  b = HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
	  a = HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
	  d = HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
	  c = HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
	  b = HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
	  a = HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
	  d = HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
	  c = HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
	  b = HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
	  a = HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
	  d = HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
	  c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
	  b = HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
	
	  /* Round 4 */
	  a = II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
	  d = II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
	  c = II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
	  b = II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
	  a = II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
	  d = II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
	  c = II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
	  b = II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
	  a = II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
	  d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
	  c = II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
	  b = II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
	  a = II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
	  d = II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
	  c = II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
	  b = II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
	
	  state[0] += a;
	  state[1] += b;
	  state[2] += c;
	  state[3] += d;
	
	  /* Zeroize sensitive information. */
	  // MD5_memset ((POINTER)x, 0, sizeof (x));
	  for ( memset=0; memset<x.length; memset++ ) x[memset]=0 ;
	     
  }

  /* Encodes input (UINT4) into output (unsigned char).
     Assumes len is a multiple of 4. */
  private void Encode ( byte [] output, int [] input , int len ) 
  {  
     int i, j;
     for (i = 0, j = 0; j < len; 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) ;
     }
   }
   private void Encode( byte [] output, long number ) 
   {
      for ( int i=0; i<8; i++ ) {
          output[i] = (byte) (number & 0x0ffL) ;
          number >>>= 8 ;
      }
   }
   
   /* Decodes input (unsigned char) into output (UINT4). 
      Assumes len is a multiple of 4. */
   private void Decode( int [] output, byte [] input, int len )
   {
      int i, j;
      for (i = 0, j = 0; j < len; i++, j += 4)
         output[i] = ( ((int)input[j]) & 0x0ff)
         | ((((int)input[j+1]) << 8) & 0x0ff00) 
         | ((((int)input[j+2]) << 16) & 0x0ff0000)
         | ((((int)input[j+3]) << 24) & 0x0ff000000) ;
   }

  // static void MD5_memcpy (output, input, len)
  // for (i = 0; i < len; i++) output[i] = input[i];
  
  // static void MD5_memset (output, value, len)
  // for (i = 0; i < len; i++) ((char *)output)[i] = (char)value;
  
    static final char [] hexdec = { '0','1','2','3','4','5','6','7','8',
    '9','a','b','c','d','e','f' } ;
    
	private void printState(int [] state, int len) {
	   // state is len integers
	   int i, j, k ;
	   for ( i=0; i<len; i++ ) {
	      k = state[i] ;
	      for ( j=0; j<8; j++ ) {
	         System.out.print(hexdec[k & 0x0f]) ;
	         k >>>= 4 ;
	      }
	      System.out.print(" ") ;
	   }
	   System.out.println() ;
	}
	
	private void printBlock(byte [] block, int len ) {
	   // block is len bytes
	   int i, j ;
	   byte k ;
	   for ( i=0; i<len; i++ ) {
	      k = block[i] ;
	      for ( j=0; j<2; j++ ) {
	         System.out.print(hexdec[k & 0x0f]) ;
	         k >>>= 4 ;
	      }
	      if ( (i+1)%8 == 0 ) System.out.println() ;
	      else System.out.print(" ") ;
	   }
	   System.out.println() ;
	}

}