MD5 16位，32位加密算法

代码如下:

using System;  
using System.Collections.Generic;  
using System.Text;

namespace MYMD5  
{   
 public class MD5   
 {   
 const int BITS_TO_A_BYTE = 8;   
 const int BYTES_TO_A_WORD = 4;   
 const int BITS_TO_A_WORD = 32;   
 private static long[] m_lOnBits = new long[30 + 1];   
 private static long[] m_l2Power = new long[30 + 1];

 private static long LShift(long lValue, long iShiftBits)   
 {   
 long LShift = 0;   
 if (iShiftBits == 0)   
 {   
 LShift = lValue;   
 return LShift;   
 }   
 else   
 {   
 if (iShiftBits == 31)   
 {   
 if (Convert.ToBoolean(lValue & 1))   
 {   
 LShift = 0x80000000;   
 }   
 else   
 {   
 LShift = 0;   
 }   
 return LShift;   
 }   
 else   
 {   
 if (iShiftBits 31)   
 {   
 // Err.Raise 6;   
 }   
 }   
 }

 if (Convert.ToBoolean((lValue & m_l2Power[31 – iShiftBits])))   
 {   
 LShift = ((lValue & m_lOnBits[31 – (iShiftBits + 1)]) * m_l2Power[iShiftBits]) | 0x80000000;   
 }   
 else   
 {   
 LShift = ((lValue & m_lOnBits[31 – iShiftBits]) * m_l2Power[iShiftBits]);   
 }

 return LShift;   
 }

 private static long RShift(long lValue, long iShiftBits)   
 {   
 long RShift = 0;   
 if (iShiftBits == 0)   
 {   
 RShift = lValue;   
 return RShift;   
 }   
 else   
 {   
 if (iShiftBits == 31)   
 {   
 if (Convert.ToBoolean(lValue & 0x80000000))   
 {   
 RShift = 1;   
 }   
 else   
 {   
 RShift = 0;   
 }   
 return RShift;   
 }   
 else   
 {   
 if (iShiftBits 31)   
 {   
 // Err.Raise 6;   
 }   
 }   
 }

 RShift = (lValue & 0x7FFFFFFE) / m_l2Power[iShiftBits];

 if (Convert.ToBoolean((lValue & 0x80000000)))   
 {   
 RShift = (RShift | (0x40000000 / m_l2Power[iShiftBits – 1]));   
 }

 return RShift;   
 }

 private static long RotateLeft(long lValue, long iShiftBits)   
 {   
 long RotateLeft = 0;   
 RotateLeft = LShift(lValue, iShiftBits) | RShift(lValue, (32 – iShiftBits));   
 return RotateLeft;   
 }

 private static long AddUnsigned(long lX, long lY)   
 {   
 long AddUnsigned = 0;   
 long lX4 = 0;   
 long lY4 = 0;   
 long lX8 = 0;   
 long lY8 = 0;   
 long lResult = 0;

 lX8 = lX & 0x80000000;   
 lY8 = lY & 0x80000000;   
 lX4 = lX & 0x40000000;   
 lY4 = lY & 0x40000000;

 lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);   
 if (Convert.ToBoolean(lX4 & lY4))   
 {   
 lResult = lResult ^ 0x80000000 ^ lX8 ^ lY8;   
 }   
 else if (Convert.ToBoolean(lX4 | lY4))   
 {   
 if (Convert.ToBoolean(lResult & 0x40000000))   
 {   
 lResult = lResult ^ 0xC0000000 ^ lX8 ^ lY8;   
 }   
 else   
 {   
 lResult = lResult ^ 0x40000000 ^ lX8 ^ lY8;   
 }   
 }   
 else   
 {   
 lResult = lResult ^ lX8 ^ lY8;   
 }   
 AddUnsigned = lResult;   
 return AddUnsigned;   
 }

 private static long md5_F(long x, long y, long z)   
 {   
 long md5_F = 0;   
 md5_F = (x & y) | ((~x) & z);   
 return md5_F;   
 }

 private static long md5_G(long x, long y, long z)   
 {   
 long md5_G = 0;   
 md5_G = (x & z) | (y & (~z));   
 return md5_G;   
 }

 private static long md5_H(long x, long y, long z)   
 {   
 long md5_H = 0;   
 md5_H = (x ^ y ^ z);   
 return md5_H;   
 }

 private static long md5_I(long x, long y, long z)   
 {   
 long md5_I = 0;   
 md5_I = (y ^ (x | (~z)));   
 return md5_I;   
 }

 private static void md5_FF(ref long a, long b, long c, long d, long x, long s, long ac)   
 {   
 a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac));   
 a = RotateLeft(a, s);   
 a = AddUnsigned(a, b);   
 }

 private static void md5_GG(ref long a, long b, long c, long d, long x, long s, long ac)   
 {   
 a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac));   
 a = RotateLeft(a, s);   
 a = AddUnsigned(a, b);   
 }

 private static void md5_HH(ref long a, long b, long c, long d, long x, long s, long ac)   
 {   
 a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac));   
 a = RotateLeft(a, s);   
 a = AddUnsigned(a, b);   
 }

 private static void md5_II(ref long a, long b, long c, long d, long x, long s, long ac)   
 {   
 a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac));   
 a = RotateLeft(a, s);   
 a = AddUnsigned(a, b);   
 }

 private static long[] ConvertToWordArray(string sMessage)   
 {   
 long[] ConvertToWordArray = null;   
 int lMessageLength = 0;   
 int lNumberOfWords = 0;   
 long[] lWordArray = null;   
 int lBytePosition = 0;   
 int lByteCount = 0;   
 int lWordCount = 0;

 const int MODULUS_BITS = 512;   
 const int CONGRUENT_BITS = 448;

 lMessageLength = sMessage.Length;   
 lNumberOfWords = (((lMessageLength + ((MODULUS_BITS – CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD);   
 lWordArray = new long[lNumberOfWords];

 lBytePosition = 0;   
 lByteCount = 0;

 while (lByteCount {   
 lWordCount = lByteCount / BYTES_TO_A_WORD;   
 lBytePosition = (lByteCount % BYTES_TO_A  
 _WORD) * BITS_TO_A_BYTE;   
 lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(Convert.ToByte(sMessage.Substring(lByteCount, 1).ToCharArray()[0]), lBytePosition);   
 lByteCount = lByteCount + 1;   
 }

 lWordCount = lByteCount / BYTES_TO_A_WORD;   
 lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE;   
 lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(0x80, lBytePosition);   
 lWordArray[lNumberOfWords – 2] = LShift(lMessageLength, 3);   
 lWordArray[lNumberOfWords – 1] = RShift(lMessageLength, 29);   
 ConvertToWordArray = lWordArray;

 return ConvertToWordArray;   
 }

 private static string WordToHex(long lValue)   
 {   
 string WordToHex = “”;   
 long lByte = 0;   
 int lCount = 0;   
 for (lCount = 0; lCount {   
 lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) & m_lOnBits[BITS_TO_A_BYTE – 1];   
 WordToHex = WordToHex + ((“0” + ToHex(lByte)).Substring((“0” + ToHex(lByte)).Length – 2));   
 }   
 return WordToHex;   
 }

 private static string ToHex(long dec)   
 {   
 string strhex = “”;   
 while (dec > 0)   
 {   
 strhex = tohex(dec % 16) + strhex;   
 dec = dec / 16;   
 }   
 return strhex;   
 }

 private static string tohex(long hex)   
 {   
 string strhex = “”;   
 switch (hex)   
 {   
 case 10: strhex = “a”; break;   
 case 11: strhex = “b”; break;   
 case 12: strhex = “c”; break;   
 case 13: strhex = “d”; break;   
 case 14: strhex = “e”; break;   
 case 15: strhex = “f”; break;   
 default: strhex = hex.ToString(); break;   
 }   
 return strhex;   
 }

 public static string Encrypt(string sMessage, int stype)   
 {   
 string MD5 = “”;

 for (int i = 0; i {   
 m_lOnBits[i] = Convert.ToInt64(Math.Pow(2, i + 1) – 1);   
 m_l2Power[i] = Convert.ToInt64(Math.Pow(2, i));   
 }

 long[] x = null;   
 int k = 0;   
 long AA = 0;   
 long BB = 0;   
 long CC = 0;   
 long DD = 0;   
 long a = 0;   
 long b = 0;   
 long c = 0;   
 long d = 0;

 const int S11 = 7;   
 const int S12 = 12;   
 const int S13 = 17;   
 const int S14 = 22;   
 const int S21 = 5;   
 const int S22 = 9;   
 const int S23 = 14;   
 const int S24 = 20;   
 const int S31 = 4;   
 const int S32 = 11;   
 const int S33 = 16;   
 const int S34 = 23;   
 const int S41 = 6;   
 const int S42 = 10;   
 const int S43 = 15;   
 const int S44 = 21;

 x = ConvertToWordArray(sMessage);

 a = 0x67452301;   
 b = 0xEFCDAB89;   
 c = 0x98BADCFE;   
 d = 0x10325476;

 for (k = 0; k {   
 AA = a;   
 BB = b;   
 CC = c;   
 DD = d;

 md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);   
 md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);   
 md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);   
 md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);   
 md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);   
 md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);   
 md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);   
 md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);   
 md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);   
 md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);   
 md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);   
 md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);   
 md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);   
 md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);   
 md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);   
 md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821);   
 md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);   
 md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);   
 md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);   
 md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);   
 md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);   
 md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);   
 md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);   
 md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);   
 md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);   
 md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);   
 md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);   
 md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);   
 md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);   
 md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);   
 md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);   
 md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);   
 md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);   
 md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);   
 md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122);   
 md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C);   
 md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);   
 md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);   
 md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);   
 md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);   
 md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);   
 md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);   
 md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);   
 md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);   
 md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);   
 md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);   
 md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);   
 md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);   
 md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);   
 md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);   
 md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);   
 md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);   
 md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);   
 md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);   
 md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);   
md5_II(refb, c, d, a, x[k + 1], S44, 0x85845DD1);  
 md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);   
 md5_II(ref d, a, b, c, x[k  
 + 15], S42, 0xFE2CE6E0);   
 md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);   
 md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);   
 md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);   
 md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);   
 md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);   
 md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);

 a = AddUnsigned(a, AA);   
 b = AddUnsigned(b, BB);   
 c = AddUnsigned(c, CC);   
 d = AddUnsigned(d, DD);   
 }

 if (stype == 32)   
 {   
 MD5 = ((((WordToHex(a)) + (WordToHex(b))) + (WordToHex(c))) + (WordToHex(d))).ToLower();   
 }   
 else   
 {   
 MD5 = ((WordToHex(b)) + (WordToHex(c))).ToLower();   
 }   
 return MD5;   
 }   
 }   
}

调用时，使用MD5.Encrypt(需要加密的string,加密类型16或者32)