CRC16/CRC32/CRC16F算法和MD5加密算法

CRC16算法和代码如下：

unsigned  short  crc16( char   * data_p, unsigned  short  length)
... {
      unsigned  char  i;
      unsigned  int  data;
      unsigned  int  crc  =   0xffff ;

       if  (length  ==   0 )
             return  ( ~ crc);

       do
       ... {
             for  (i = 0 , data = (unsigned  int ) 0xff   &   * data_p ++ ;
                 i  <   8 ;
                 i ++ , data  > ; > ; =   1 )
             ... {
                   if  ((crc  &   0x0001 )  ^  (data  &   0x0001 ))
                        crc  =  (crc  > ; > ;  1 )  ^  POLY;
                   else   crc  > ; > ; =   1 ;
            }
      }   while  ( -- length);

      crc  =   ~ crc;
      data  =  crc;
      crc  =  (crc  <<   8 )  |  (data  > ; > ;  8   &   0xff );

       return  (crc);
}

CRC16F算法和代码：

#define    P    0x1021

#define  W 16

#define  B 8

static  unsigned  short  crctab[ 1 << B]  =   ... {  /**/ /*  as calculated by initcrctab()  */
     0x0000 ,   0x1021 ,   0x2042 ,   0x3063 ,   0x4084 ,   0x50a5 ,   0x60c6 ,   0x70e7 ,
     0x8108 ,   0x9129 ,   0xa14a ,   0xb16b ,   0xc18c ,   0xd1ad ,   0xe1ce ,   0xf1ef ,
     0x1231 ,   0x0210 ,   0x3273 ,   0x2252 ,   0x52b5 ,   0x4294 ,   0x72f7 ,   0x62d6 ,
     0x9339 ,   0x8318 ,   0xb37b ,   0xa35a ,   0xd3bd ,   0xc39c ,   0xf3ff ,   0xe3de ,
     0x2462 ,   0x3443 ,   0x0420 ,   0x1401 ,   0x64e6 ,   0x74c7 ,   0x44a4 ,   0x5485 ,
     0xa56a ,   0xb54b ,   0x8528 ,   0x9509 ,   0xe5ee ,   0xf5cf ,   0xc5ac ,   0xd58d ,
     0x3653 ,   0x2672 ,   0x1611 ,   0x0630 ,   0x76d7 ,   0x66f6 ,   0x5695 ,   0x46b4 ,
     0xb75b ,   0xa77a ,   0x9719 ,   0x8738 ,   0xf7df ,   0xe7fe ,   0xd79d ,   0xc7bc ,
     0x48c4 ,   0x58e5 ,   0x6886 ,   0x78a7 ,   0x0840 ,   0x1861 ,   0x2802 ,   0x3823 ,
     0xc9cc ,   0xd9ed ,   0xe98e ,   0xf9af ,   0x8948 ,   0x9969 ,   0xa90a ,   0xb92b ,
     0x5af5 ,   0x4ad4 ,   0x7ab7 ,   0x6a96 ,   0x1a71 ,   0x0a50 ,   0x3a33 ,   0x2a12 ,
     0xdbfd ,   0xcbdc ,   0xfbbf ,   0xeb9e ,   0x9b79 ,   0x8b58 ,   0xbb3b ,   0xab1a ,
     0x6ca6 ,   0x7c87 ,   0x4ce4 ,   0x5cc5 ,   0x2c22 ,   0x3c03 ,   0x0c60 ,   0x1c41 ,
     0xedae ,   0xfd8f ,   0xcdec ,   0xddcd ,   0xad2a ,   0xbd0b ,   0x8d68 ,   0x9d49 ,
     0x7e97 ,   0x6eb6 ,   0x5ed5 ,   0x4ef4 ,   0x3e13 ,   0x2e32 ,   0x1e51 ,   0x0e70 ,
     0xff9f ,   0xefbe ,   0xdfdd ,   0xcffc ,   0xbf1b ,   0xaf3a ,   0x9f59 ,   0x8f78 ,
     0x9188 ,   0x81a9 ,   0xb1ca ,   0xa1eb ,   0xd10c ,   0xc12d ,   0xf14e ,   0xe16f ,
     0x1080 ,   0x00a1 ,   0x30c2 ,   0x20e3 ,   0x5004 ,   0x4025 ,   0x7046 ,   0x6067 ,
     0x83b9 ,   0x9398 ,   0xa3fb ,   0xb3da ,   0xc33d ,   0xd31c ,   0xe37f ,   0xf35e ,
     0x02b1 ,   0x1290 ,   0x22f3 ,   0x32d2 ,   0x4235 ,   0x5214 ,   0x6277 ,   0x7256 ,
     0xb5ea ,   0xa5cb ,   0x95a8 ,   0x8589 ,   0xf56e ,   0xe54f ,   0xd52c ,   0xc50d ,
     0x34e2 ,   0x24c3 ,   0x14a0 ,   0x0481 ,   0x7466 ,   0x6447 ,   0x5424 ,   0x4405 ,
     0xa7db ,   0xb7fa ,   0x8799 ,   0x97b8 ,   0xe75f ,   0xf77e ,   0xc71d ,   0xd73c ,
     0x26d3 ,   0x36f2 ,   0x0691 ,   0x16b0 ,   0x6657 ,   0x7676 ,   0x4615 ,   0x5634 ,
     0xd94c ,   0xc96d ,   0xf90e ,   0xe92f ,   0x99c8 ,   0x89e9 ,   0xb98a ,   0xa9ab ,
     0x5844 ,   0x4865 ,   0x7806 ,   0x6827 ,   0x18c0 ,   0x08e1 ,   0x3882 ,   0x28a3 ,
     0xcb7d ,   0xdb5c ,   0xeb3f ,   0xfb1e ,   0x8bf9 ,   0x9bd8 ,   0xabbb ,   0xbb9a ,
     0x4a75 ,   0x5a54 ,   0x6a37 ,   0x7a16 ,   0x0af1 ,   0x1ad0 ,   0x2ab3 ,   0x3a92 ,
     0xfd2e ,   0xed0f ,   0xdd6c ,   0xcd4d ,   0xbdaa ,   0xad8b ,   0x9de8 ,   0x8dc9 ,
     0x7c26 ,   0x6c07 ,   0x5c64 ,   0x4c45 ,   0x3ca2 ,   0x2c83 ,   0x1ce0 ,   0x0cc1 ,
     0xef1f ,   0xff3e ,   0xcf5d ,   0xdf7c ,   0xaf9b ,   0xbfba ,   0x8fd9 ,   0x9ff8 ,
     0x6e17 ,   0x7e36 ,   0x4e55 ,   0x5e74 ,   0x2e93 ,   0x3eb2 ,   0x0ed1 ,   0x1ef0
    } ;

unsigned  short  updcrc(unsigned  short  icrc,
                      unsigned  char   * icp,
                      unsigned  int  icnt )
... {
      register unsigned  short  crc  =  icrc;
      register unsigned  char   * cp  =  icp;
      register unsigned  int  cnt  =  icnt;

       while ( cnt --  )
            crc  =  (crc << B)  ^  crctab[(crc > ; > ;(W - B))  ^   * cp ++ ];

       return ( crc );
}

#ifdef MAKETAB
main()
... {
      initcrctab();
}

initcrctab()
... {
      register  b, v, i;

       for ( b  =   0 ; b  <=  ( 1 << B) - 1 ;  ++ b )
       ... {
             for ( v  =  b << (W - B), i  =  B;  -- i  > ; =   0 ; )
                  v  =  v & 0x8000   ?  (v << 1 ) ^ P : v << 1 ;
            crctab[b]  =  v;

            printf(  " 0x%04x, " , v  &   0xFFFF  );
             if ( (b & 7 )  ==   7  )
                  printf( " "  );
             else   printf( "    " );
      }
}
#endif

#ifdef TEST

#include  < stdio.h > ;
#include  < fcntl.h > ;

#define  MAXBUF 4096

void  main( int  argc,  char   ** argv)
... {
       int  fd  =   0 ;
       int  nr;
       char  buf[MAXBUF];
      unsigned  short  crc;

       if ( argc  > ;  1  )
       ... {
             if ( (fd  =  open( argv[ 1 ], O_RDONLY ))  <   0  )
             ... {
                  perror( argv[ 1 ] );
                  exit(  - 1  );
            }
      }
      crc  =   0 ;
       while ( (nr  =  read( fd, buf, MAXBUF ))  > ;  0  )
            crc  =  updcrc( crc, buf, nr );
      printf(  " %04x " , crc );
       if ( nr  !=   0  )
            perror(  " reading "  );
}

#endif

CRC32算法和代码：

#include  < stdio.h >
#define  OK 0
#define  ERROR (-1)

static   long  crc_32_tab[]  =   ... {  /**/ /*  CRC polynomial 0xedb88320  */
0x00000000 ,  0x77073096 ,  0xee0e612c ,  0x990951ba ,  0x076dc419 ,  0x706af48f ,
0xe963a535 ,  0x9e6495a3 ,  0x0edb8832 ,  0x79dcb8a4 ,  0xe0d5e91e ,  0x97d2d988 ,
0x09b64c2b ,  0x7eb17cbd ,  0xe7b82d07 ,  0x90bf1d91 ,  0x1db71064 ,  0x6ab020f2 ,
0xf3b97148 ,  0x84be41de ,  0x1adad47d ,  0x6ddde4eb ,  0xf4d4b551 ,  0x83d385c7 ,
0x136c9856 ,  0x646ba8c0 ,  0xfd62f97a ,  0x8a65c9ec ,  0x14015c4f ,  0x63066cd9 ,
0xfa0f3d63 ,  0x8d080df5 ,  0x3b6e20c8 ,  0x4c69105e ,  0xd56041e4 ,  0xa2677172 ,
0x3c03e4d1 ,  0x4b04d447 ,  0xd20d85fd ,  0xa50ab56b ,  0x35b5a8fa ,  0x42b2986c ,
0xdbbbc9d6 ,  0xacbcf940 ,  0x32d86ce3 ,  0x45df5c75 ,  0xdcd60dcf ,  0xabd13d59 ,
0x26d930ac ,  0x51de003a ,  0xc8d75180 ,  0xbfd06116 ,  0x21b4f4b5 ,  0x56b3c423 ,
0xcfba9599 ,  0xb8bda50f ,  0x2802b89e ,  0x5f058808 ,  0xc60cd9b2 ,  0xb10be924 ,
0x2f6f7c87 ,  0x58684c11 ,  0xc1611dab ,  0xb6662d3d ,  0x76dc4190 ,  0x01db7106 ,
0x98d220bc ,  0xefd5102a ,  0x71b18589 ,  0x06b6b51f ,  0x9fbfe4a5 ,  0xe8b8d433 ,
0x7807c9a2 ,  0x0f00f934 ,  0x9609a88e ,  0xe10e9818 ,  0x7f6a0dbb ,  0x086d3d2d ,
0x91646c97 ,  0xe6635c01 ,  0x6b6b51f4 ,  0x1c6c6162 ,  0x856530d8 ,  0xf262004e ,
0x6c0695ed ,  0x1b01a57b ,  0x8208f4c1 ,  0xf50fc457 ,  0x65b0d9c6 ,  0x12b7e950 ,
0x8bbeb8ea ,  0xfcb9887c ,  0x62dd1ddf ,  0x15da2d49 ,  0x8cd37cf3 ,  0xfbd44c65 ,
0x4db26158 ,  0x3ab551ce ,  0xa3bc0074 ,  0xd4bb30e2 ,  0x4adfa541 ,  0x3dd895d7 ,
0xa4d1c46d ,  0xd3d6f4fb ,  0x4369e96a ,  0x346ed9fc ,  0xad678846 ,  0xda60b8d0 ,
0x44042d73 ,  0x33031de5 ,  0xaa0a4c5f ,  0xdd0d7cc9 ,  0x5005713c ,  0x270241aa ,
0xbe0b1010 ,  0xc90c2086 ,  0x5768b525 ,  0x206f85b3 ,  0xb966d409 ,  0xce61e49f ,
0x5edef90e ,  0x29d9c998 ,  0xb0d09822 ,  0xc7d7a8b4 ,  0x59b33d17 ,  0x2eb40d81 ,
0xb7bd5c3b ,  0xc0ba6cad ,  0xedb88320 ,  0x9abfb3b6 ,  0x03b6e20c ,  0x74b1d29a ,
0xead54739 ,  0x9dd277af ,  0x04db2615 ,  0x73dc1683 ,  0xe3630b12 ,  0x94643b84 ,
0x0d6d6a3e ,  0x7a6a5aa8 ,  0xe40ecf0b ,  0x9309ff9d ,  0x0a00ae27 ,  0x7d079eb1 ,
0xf00f9344 ,  0x8708a3d2 ,  0x1e01f268 ,  0x6906c2fe ,  0xf762575d ,  0x806567cb ,
0x196c3671 ,  0x6e6b06e7 ,  0xfed41b76 ,  0x89d32be0 ,  0x10da7a5a ,  0x67dd4acc ,
0xf9b9df6f ,  0x8ebeeff9 ,  0x17b7be43 ,  0x60b08ed5 ,  0xd6d6a3e8 ,  0xa1d1937e ,
0x38d8c2c4 ,  0x4fdff252 ,  0xd1bb67f1 ,  0xa6bc5767 ,  0x3fb506dd ,  0x48b2364b ,
0xd80d2bda ,  0xaf0a1b4c ,  0x36034af6 ,  0x41047a60 ,  0xdf60efc3 ,  0xa867df55 ,
0x316e8eef ,  0x4669be79 ,  0xcb61b38c ,  0xbc66831a ,  0x256fd2a0 ,  0x5268e236 ,
0xcc0c7795 ,  0xbb0b4703 ,  0x220216b9 ,  0x5505262f ,  0xc5ba3bbe ,  0xb2bd0b28 ,
0x2bb45a92 ,  0x5cb36a04 ,  0xc2d7ffa7 ,  0xb5d0cf31 ,  0x2cd99e8b ,  0x5bdeae1d ,
0x9b64c2b0 ,  0xec63f226 ,  0x756aa39c ,  0x026d930a ,  0x9c0906a9 ,  0xeb0e363f ,
0x72076785 ,  0x05005713 ,  0x95bf4a82 ,  0xe2b87a14 ,  0x7bb12bae ,  0x0cb61b38 ,
0x92d28e9b ,  0xe5d5be0d ,  0x7cdcefb7 ,  0x0bdbdf21 ,  0x86d3d2d4 ,  0xf1d4e242 ,
0x68ddb3f8 ,  0x1fda836e ,  0x81be16cd ,  0xf6b9265b ,  0x6fb077e1 ,  0x18b74777 ,
0x88085ae6 ,  0xff0f6a70 ,  0x66063bca ,  0x11010b5c ,  0x8f659eff ,  0xf862ae69 ,
0x616bffd3 ,  0x166ccf45 ,  0xa00ae278 ,  0xd70dd2ee ,  0x4e048354 ,  0x3903b3c2 ,
0xa7672661 ,  0xd06016f7 ,  0x4969474d ,  0x3e6e77db ,  0xaed16a4a ,  0xd9d65adc ,
0x40df0b66 ,  0x37d83bf0 ,  0xa9bcae53 ,  0xdebb9ec5 ,  0x47b2cf7f ,  0x30b5ffe9 ,
0xbdbdf21c ,  0xcabac28a ,  0x53b39330 ,  0x24b4a3a6 ,  0xbad03605 ,  0xcdd70693 ,
0x54de5729 ,  0x23d967bf ,  0xb3667a2e ,  0xc4614ab8 ,  0x5d681b02 ,  0x2a6f2b94 ,
0xb40bbe37 ,  0xc30c8ea1 ,  0x5a05df1b ,  0x2d02ef8d
} ;

#define  UPDC32(octet, crc) (crc_32_tab[((crc)
      ^  (octet))  &   0xff ]  ^  ((crc)  >>   8 ))

int  crc32file( char   * name);

int  main( int  argc,  char   * argv[])
... {
      register  int  errors  =   0 ;

//       while(--argc > 0)
//             errors |= crc32file( *++argv);
      crc32file( "" );
       return (errors  !=   0 );
}

int  crc32file( char   * name)
... {
      register FILE  * fin;
      register unsigned  long  oldcrc32;
      register unsigned  long  crc32;
      register unsigned  long  oldcrc;
      register  int  c;
      register  long  charcnt;

      oldcrc32  =   0xFFFFFFFF ; charcnt  =   0 ;
/**/ /*
#ifdef MSDOS
      if ((fin=fopen(name, "rb"))==NULL)
#else
      if ((fin=fopen(name, "r"))==NULL)
#endif
      {
            perror(name);
            return ERROR;
      }
      while ((c=getc(fin))!=EOF)
      {
            ++charcnt;
            oldcrc32 = UPDC32(c, oldcrc32);
      }

      if (ferror(fin))
      {
            perror(name);
            charcnt = -1;
      }
      fclose(fin);
*/

       char  s[ 33 ], * p = s;
      gets(s);
       while ( * p != 0 )
       ... {
         charcnt ++ ;
         oldcrc32  =  UPDC32( * p,oldcrc32);
         p ++ ;
      }
      crc32  =  oldcrc32;  oldcrc  =  oldcrc32  =   ~ oldcrc32;
      
      crc32  =  UPDC32((oldcrc32  &   0377 ), crc32);  oldcrc32  >>= 8 ;
      crc32  =  UPDC32((oldcrc32  &   0377 ), crc32);  oldcrc32  >>= 8 ;
      crc32  =  UPDC32((oldcrc32  &   0377 ), crc32);  oldcrc32  >>= 8 ;
      crc32  =  UPDC32((oldcrc32  &   0377 ), crc32);  oldcrc32  >>= 8 ;
      printf( " %08lX  " , crc32);

      printf( " %08lX %7ld " , oldcrc, charcnt);
      //  printf("%08lX %7ld %s ", oldcrc, charcnt, name);

       return  OK;
}

MD5加密算法：

// #ifndef _MD5_H_
// #define _MD5_H_


char *  MD5String(  char *   string  );


bool  MD5Check(  char   * md5string,  char *   string  );

// #endif  // _MD5_H_




// #include "stdafx.h"
#include < stdio.h >
#include < stdlib.h >
#include < string .h >
#include < math.h >
#include < ctype.h >
// #include "md5.h"

/**/ /*  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;

#define  PROTO_LIST(list) list

/**/ /*  MD5 context.  */
typedef  struct  _MD5_CTX
... {
UINT4 state[ 4 ];  /**/ /*  state (ABCD)  */
UINT4 count[ 2 ];  /**/ /*  number of bits, modulo 2^64 (lsb first)  */
unsigned  char  buffer[ 64 ];  /**/ /*  input buffer  */
}  MD5_CTX;

/**/ /*  Constants for MD5Transform routine.
*/
#define  S11 7
#define  S12 12
#define  S13 17
#define  S14 22
#define  S21 5
#define  S22 9
#define  S23 14
#define  S24 20
#define  S31 4
#define  S32 11
#define  S33 16
#define  S34 23
#define  S41 6
#define  S42 10
#define  S43 15
#define  S44 21

static  unsigned  char  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
} ;

/**/ /*  F, G, H and I are basic MD5 functions.
*/
#define  F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define  G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define  H(x, y, z) ((x) ^ (y) ^ (z))
#define  I(x, y, z) ((y) ^ ((x) | (~z)))

/**/ /*  ROTATE_LEFT rotates x left n bits.
*/
#define  ROTATE_LEFT(x, n) (((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.
*/
#define  FF(a, b, c, d, x, s, ac) { 
(a)  +=  F ((b), (c), (d))  +  (x)  +  (UINT4)(ac);
(a)  =  ROTATE_LEFT ((a), (s)); 
(a)  +=  (b); 
}
#define  GG(a, b, c, d, x, s, ac) { 
(a)  +=  G ((b), (c), (d))  +  (x)  +  (UINT4)(ac); 
(a)  =  ROTATE_LEFT ((a), (s)); 
(a)  +=  (b); 
}
#define  HH(a, b, c, d, x, s, ac) { 
(a)  +=  H ((b), (c), (d))  +  (x)  +  (UINT4)(ac); 
(a)  =  ROTATE_LEFT ((a), (s)); 
(a)  +=  (b); 
}
#define  II(a, b, c, d, x, s, ac) { 
(a)  +=  I ((b), (c), (d))  +  (x)  +  (UINT4)(ac); 
(a)  =  ROTATE_LEFT ((a), (s)); 
(a)  +=  (b); 
}

#define  TEST_BLOCK_LEN 1000
#define  TEST_BLOCK_COUNT 1000

static   void  MD5Transform PROTO_LIST ((UINT4 [ 4 ], unsigned  char  [ 64 ]));
static   void  Encode PROTO_LIST ((unsigned  char   * , UINT4  * , unsigned  int ));
static   void  Decode PROTO_LIST ((UINT4  * , unsigned  char   * , unsigned  int ));
static   void  MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned  int ));
static   void  MD5_memset PROTO_LIST ((POINTER,  int , unsigned  int ));
static   void  MD5Init PROTO_LIST ((MD5_CTX  * ));
static   void  MD5Update PROTO_LIST ((MD5_CTX  * , unsigned  char   * , unsigned  int ));
static   void  MD5Final PROTO_LIST ((unsigned  char  [ 16 ], MD5_CTX  * ));
static   void  MDTimeTrial PROTO_LIST (( void ));
static   void  StringAddOne PROTO_LIST (( char   * ));
static   void  Encode PROTO_LIST ((unsigned  char   * , UINT4  * , unsigned  int ));
static   void  Decode PROTO_LIST ((UINT4  * , unsigned  char   * , unsigned  int ));

/**/ /*  MD5 initialization. Begins an MD5 operation, writing a new context.
*/
static   void  MD5Init( MD5_CTX  * context )
... {
context -> count[ 0 ]  =  context -> count[ 1 ]  =   0 ;
/**/ /*  Load magic initialization constants.
*/
context -> state[ 0 ]  =   0x67452301 ;
context -> state[ 1 ]  =   0xefcdab89 ;
context -> state[ 2 ]  =   0x98badcfe ;
context -> state[ 3 ]  =   0x10325476 ;
}

/**/ /*  MD5 block update operation. Continues an MD5 message-digest
operation, processing another message block, and updating the
context.
*/
static   void  MD5Update(
MD5_CTX  * context,  /**/ /*  context  */
unsigned  char   * input,  /**/ /*  input block  */
unsigned  int  inputLen  /**/ /*  length of input block  */
)
... {
unsigned  int  i, index, partLen;

/**/ /*  Compute number of bytes mod 64  */
index  =  (unsigned  int )((context -> count[ 0 ]  >>   3 )  &   0x3F );

/**/ /*  Update number of bits  */
if  ((context -> count[ 0 ]  +=  ((UINT4)inputLen  <<   3 ))
<  ((UINT4)inputLen  <<   3 ))
context -> count[ 1 ] ++ ;
context -> count[ 1 ]  +=  ((UINT4)inputLen  >>   29 );

partLen  =   64   -  index;

/**/ /*  Transform as many times as possible.
*/
if  (inputLen  >=  partLen)  ... {
MD5_memcpy
((POINTER) & context -> buffer[index], (POINTER)input, partLen);
MD5Transform (context -> state, context -> buffer);

for  (i  =  partLen; i  +   63   <  inputLen; i  +=   64 )
MD5Transform (context -> state,  & input[i]);

index  =   0 ;
}
else
i  =   0 ;

/**/ /*  Buffer remaining input  */
MD5_memcpy
((POINTER) & context -> buffer[index], (POINTER) & input[i],
inputLen - i);
}

/**/ /*  MD5 finalization. Ends an MD5 message-digest operation, writing the
the message digest and zeroizing the context.
*/
static   void  MD5Final(
unsigned  char  digest[ 16 ],  /**/ /*  message digest  */
MD5_CTX  * context  /**/ /*  context  */
)
... {
unsigned  char  bits[ 8 ];
unsigned  int  index, padLen;

/**/ /*  Save number of bits  */
Encode (bits, context -> count,  8 );

/**/ /*  Pad out to 56 mod 64.
*/
index  =  (unsigned  int )((context -> count[ 0 ]  >>   3 )  &   0x3f );
padLen  =  (index  <   56 )  ?  ( 56   -  index) : ( 120   -  index);
MD5Update (context, PADDING, padLen);

/**/ /*  Append length (before padding)  */
MD5Update (context, bits,  8 );

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

/**/ /*  Zeroize sensitive information.
*/
MD5_memset ((POINTER)context,  0 ,  sizeof  ( * context));
}

/**/ /*  MD5 basic transformation. Transforms state based on block.
*/
static   void  MD5Transform(
UINT4 state[ 4 ],
unsigned  char  block[ 64 ]
)
... {
UINT4 a  =  state[ 0 ], b  =  state[ 1 ], c  =  state[ 2 ], d  =  state[ 3 ], x[ 16 ];

Decode (x, block,  64 );

/**/ /*  Round 1  */
FF (a, b, c, d, x[  0 ], S11,  0xd76aa478 );  /**/ /*  1  */
FF (d, a, b, c, x[  1 ], S12,  0xe8c7b756 );  /**/ /*  2  */
FF (c, d, a, b, x[  2 ], S13,  0x242070db );  /**/ /*  3  */
FF (b, c, d, a, x[  3 ], S14,  0xc1bdceee );  /**/ /*  4  */
FF (a, b, c, d, x[  4 ], S11,  0xf57c0faf );  /**/ /*  5  */
FF (d, a, b, c, x[  5 ], S12,  0x4787c62a );  /**/ /*  6  */
FF (c, d, a, b, x[  6 ], S13,  0xa8304613 );  /**/ /*  7  */
FF (b, c, d, a, x[  7 ], S14,  0xfd469501 );  /**/ /*  8  */
FF (a, b, c, d, x[  8 ], S11,  0x698098d8 );  /**/ /*  9  */
FF (d, a, b, c, x[  9 ], S12,  0x8b44f7af );  /**/ /*  10  */
FF (c, d, a, b, x[ 10 ], S13,  0xffff5bb1 );  /**/ /*  11  */
FF (b, c, d, a, x[ 11 ], S14,  0x895cd7be );  /**/ /*  12  */
FF (a, b, c, d, x[ 12 ], S11,  0x6b901122 );  /**/ /*  13  */
FF (d, a, b, c, x[ 13 ], S12,  0xfd987193 );  /**/ /*  14  */
FF (c, d, a, b, x[ 14 ], S13,  0xa679438e );  /**/ /*  15  */
FF (b, c, d, a, x[ 15 ], S14,  0x49b40821 );  /**/ /*  16  */

/**/ /*  Round 2  */
GG (a, b, c, d, x[  1 ], S21,  0xf61e2562 );  /**/ /*  17  */
GG (d, a, b, c, x[  6 ], S22,  0xc040b340 );  /**/ /*  18  */
GG (c, d, a, b, x[ 11 ], S23,  0x265e5a51 );  /**/ /*  19  */
GG (b, c, d, a, x[  0 ], S24,  0xe9b6c7aa );  /**/ /*  20  */
GG (a, b, c, d, x[  5 ], S21,  0xd62f105d );  /**/ /*  21  */
GG (d, a, b, c, x[ 10 ], S22,  0x2441453 );  /**/ /*  22  */
GG (c, d, a, b, x[ 15 ], S23,  0xd8a1e681 );  /**/ /*  23  */
GG (b, c, d, a, x[  4 ], S24,  0xe7d3fbc8 );  /**/ /*  24  */
GG (a, b, c, d, x[  9 ], S21,  0x21e1cde6 );  /**/ /*  25  */
GG (d, a, b, c, x[ 14 ], S22,  0xc33707d6 );  /**/ /*  26  */
GG (c, d, a, b, x[  3 ], S23,  0xf4d50d87 );  /**/ /*  27  */
GG (b, c, d, a, x[  8 ], S24,  0x455a14ed );  /**/ /*  28  */
GG (a, b, c, d, x[ 13 ], S21,  0xa9e3e905 );  /**/ /*  29  */
GG (d, a, b, c, x[  2 ], S22,  0xfcefa3f8 );  /**/ /*  30  */
GG (c, d, a, b, x[  7 ], S23,  0x676f02d9 );  /**/ /*  31  */
GG (b, c, d, a, x[ 12 ], S24,  0x8d2a4c8a );  /**/ /*  32  */

/**/ /*  Round 3  */
HH (a, b, c, d, x[  5 ], S31,  0xfffa3942 );  /**/ /*  33  */
HH (d, a, b, c, x[  8 ], S32,  0x8771f681 );  /**/ /*  34  */
HH (c, d, a, b, x[ 11 ], S33,  0x6d9d6122 );  /**/ /*  35  */
HH (b, c, d, a, x[ 14 ], S34,  0xfde5380c );  /**/ /*  36  */
HH (a, b, c, d, x[  1 ], S31,  0xa4beea44 );  /**/ /*  37  */
HH (d, a, b, c, x[  4 ], S32,  0x4bdecfa9 );  /**/ /*  38  */
HH (c, d, a, b, x[  7 ], S33,  0xf6bb4b60 );  /**/ /*  39  */
HH (b, c, d, a, x[ 10 ], S34,  0xbebfbc70 );  /**/ /*  40  */
HH (a, b, c, d, x[ 13 ], S31,  0x289b7ec6 );  /**/ /*  41  */
HH (d, a, b, c, x[  0 ], S32,  0xeaa127fa );  /**/ /*  42  */
HH (c, d, a, b, x[  3 ], S33,  0xd4ef3085 );  /**/ /*  43  */
HH (b, c, d, a, x[  6 ], S34,  0x4881d05 );  /**/ /*  44  */
HH (a, b, c, d, x[  9 ], S31,  0xd9d4d039 );  /**/ /*  45  */
HH (d, a, b, c, x[ 12 ], S32,  0xe6db99e5 );  /**/ /*  46  */
HH (c, d, a, b, x[ 15 ], S33,  0x1fa27cf8 );  /**/ /*  47  */
HH (b, c, d, a, x[  2 ], S34,  0xc4ac5665 );  /**/ /*  48  */

/**/ /*  Round 4  */
II (a, b, c, d, x[  0 ], S41,  0xf4292244 );  /**/ /*  49  */
II (d, a, b, c, x[  7 ], S42,  0x432aff97 );  /**/ /*  50  */
II (c, d, a, b, x[ 14 ], S43,  0xab9423a7 );  /**/ /*  51  */
II (b, c, d, a, x[  5 ], S44,  0xfc93a039 );  /**/ /*  52  */
II (a, b, c, d, x[ 12 ], S41,  0x655b59c3 );  /**/ /*  53  */
II (d, a, b, c, x[  3 ], S42,  0x8f0ccc92 );  /**/ /*  54  */
II (c, d, a, b, x[ 10 ], S43,  0xffeff47d );  /**/ /*  55  */
II (b, c, d, a, x[  1 ], S44,  0x85845dd1 );  /**/ /*  56  */
II (a, b, c, d, x[  8 ], S41,  0x6fa87e4f );  /**/ /*  57  */
II (d, a, b, c, x[ 15 ], S42,  0xfe2ce6e0 );  /**/ /*  58  */
II (c, d, a, b, x[  6 ], S43,  0xa3014314 );  /**/ /*  59  */
II (b, c, d, a, x[ 13 ], S44,  0x4e0811a1 );  /**/ /*  60  */
II (a, b, c, d, x[  4 ], S41,  0xf7537e82 );  /**/ /*  61  */
II (d, a, b, c, x[ 11 ], S42,  0xbd3af235 );  /**/ /*  62  */
II (c, d, a, b, x[  2 ], S43,  0x2ad7d2bb );  /**/ /*  63  */
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));
}

/**/ /*  Encodes input (UINT4) into output (unsigned char). Assumes len is
a multiple of 4.
*/
static   void  Encode(
unsigned  char   * output,
UINT4  * input,
unsigned  int  len
)
... {
unsigned  int  i, j;

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

/**/ /*  Decodes input (unsigned char) into output (UINT4). Assumes len is
a multiple of 4.
*/
static   void  Decode(
UINT4  * output,
unsigned  char   * input,
unsigned  int  len
)
... {
unsigned  int  i, j;

for  (i  =   0 , j  =   0 ; j  <  len; i ++ , j  +=   4 )
output[i]  =  ((UINT4)input[j])  |  (((UINT4)input[j + 1 ])  <<   8 )  |
(((UINT4)input[j + 2 ])  <<   16 )  |  (((UINT4)input[j + 3 ])  <<   24 );
}

/**/ /*  Note: Replace "for loop" with standard memcpy if possible.
*/
static   void  MD5_memcpy(
POINTER output,
POINTER input,
unsigned  int  len
)
... {
unsigned  int  i;

for  (i  =   0 ; i  <  len; i ++ )
output[i]  =  input[i];
}

/**/ /*  Note: Replace "for loop" with standard memset if possible.
*/
static   void  MD5_memset(
POINTER output,
int  value,
unsigned  int  len
)
... {
unsigned  int  i;

for  (i  =   0 ; i  <  len; i ++ )
(( char   * )output)[i]  =  ( char )value;
}

/**/ /*  Digests a string and prints the result.
*/
char *  MD5String(  char   * string  )
... {
MD5_CTX context;
unsigned  char  digest[ 16 ];
char  output1[ 33 ];
static   char  output[ 33 ] = ... { "" } ;
unsigned  int  len  =  strlen ( string );
int  i;

MD5Init(  & context);
MD5Update(  & context, (unsigned  char * ) string , len );
MD5Final( digest,  & context );

for  (i  =   0 ; i  <   16 ; i ++ )
... {
sprintf( & (output1[ 2 * i]), " %02x " ,(unsigned  char )digest[i]);
sprintf( & (output1[ 2 * i + 1 ]), " %02x " ,(unsigned  char )(digest[i] << 4 ));
}
for (i = 0 ;i < 32 ;i ++ )
... {
output[i] = output1[i];
}
return  output;
}

/**/ /*  get the string add one.
*/
static   void  StringAddOne(  char   *  orstring )
... {
unsigned  int  len;
int  i,n;

len  =  strlen(orstring);
n  =  len  -   1 ;
for (i  =  n; i  >=   0 ; i -- )
... {
if (orstring[i] == ' 9 ' )
... {
orstring[i]  =   ' A ' ;
break ;
}
else   if (orstring[i] == ' Z ' )
... {
orstring[i] = ' a ' ;
break ;
}
else   if (orstring[i] == ' z ' )
... {
orstring[i] = ' 0 ' ;
continue ;
}
else
orstring[i]  +=   1 ;
break ;
}
}

/**/ /*  check the md5 strings one by one,get the password.
*/
bool  MD5Check(  char   * md5string,  char *   string  )
... {
return  strcmp( md5string, MD5String(  string  ) )  ==   0 ;
}

int  main()
... {
     char  s[ 33 ];
    gets(s);
    printf( " %s " ,MD5String(s));
     return   0 ;
}