C#中使用MD5加密的方法

来源：互联网发布：华为海思媒体算法编辑：程序博客网时间：2024/06/06 07:21

---------------------第1组---------------------

【方法一】

首先,先简单介绍一下MD5

MD5的全称是message-digest algorithm 5(信息-摘要算法，在90年代初由mit laboratory for computer science和rsa data security inc的ronald l. rivest开发出来，经md2、md3和md4发展而来。

MD5具有很好的安全性(因为它具有不可逆的特征,加过密的密文经过解密后和加密前的东东相同的可能性极小)

引用

[c-sharp] view plain copy
using System.Security.Cryptography;  
using System.Text;  

具体代码如下(写在按钮的Click事件里):

[c-sharp] view plain copy
byte[] result = Encoding.Default.GetBytes(this.tbPass.Text.Trim());    //tbPass为输入密码的文本框  
MD5 md5 = new MD5CryptoServiceProvider();  
byte[] output = md5.ComputeHash(result);  
this.tbMd5pass.Text = BitConverter.ToString(output).Replace("-","");  //tbMd5pass为输出加密文本的文本框  

【方法二】

[c-sharp] view plain copy
C# md5加密（上）  
string a; //加密前数据  
string b; //加密后数据  
b=System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(a,"MD5")  
  
using   System;  
using   System.Security.Cryptography;  
  
方法2  
  
public   static   string   GetMD5(string   myString)     
{  
MD5   md5     =   new   MD5CryptoServiceProvider();  
byte[]   fromData   =   System.Text.Encoding.Unicode.GetBytes(myString);  
byte[]   targetData   =   md5.ComputeHash(fromData);  
string   byte2String   =   null;  
  
for   (int   i=0;   i<targetData.Length;   i++)     
{  
byte2String   +=   targetData[i].ToString("x");  
}  
  
return   byte2String;  
}   
  
using   System.Security.Cryptography;  
  
  
///   <summary>  
///   给一个字符串进行MD5加密  
///   </summary>  
///   <param   name="strText">待加密字符串</param>  
///   <returns>加密后的字符串</returns>  
public   static   string   MD5Encrypt(string   strText)  
{     
MD5   md5   =   new   MD5CryptoServiceProvider();  
byte[]   result   =   md5.ComputeHash(System.Text.Encoding.Default.GetBytes(strText));  
return   System.Text.Encoding.Default.GetString(result);  
}   

C# MD5加密

[c-sharp] view plain copy
using System.Security.Cryptography;  
  
  
private void btnOK_Click(object sender, System.EventArgs e)  
{  
   string strConn = "server=192.168.0.51;database=chengheng;User id=sa; password=123";  
   if(texName.Text.Trim()=="")  
   {  
    this.RegisterStartupScript("sf","<mce:script language='<a href="http://lib.csdn.net/base/javascript" class='replace_word' title="JavaScript知识库" target='_blank' style='color:#df3434; font-weight:bold;'>JavaScript</a>'><!--  
alert('用户名不能为空');document.all('texName').focus()  
// --></mce:script>");  
    return;  
   }  
   else if(texPassword.Text.Trim()=="")  
   {  
    this.RegisterStartupScript("sfs","<mce:script language='javascript'><!--  
alert('密码不能为空');document.all('texPassword').focus()  
// --></mce:script>");  
    return;  
   }  
   else  
   {  
    //将获取的密码加密与<a href="http://lib.csdn.net/base/mysql" class='replace_word' title="MySQL知识库" target='_blank' style='color:#df3434; font-weight:bold;'>数据库</a>中加了密的密码相比较  
    byte[] by = md5.ComputeHash(utf.GetBytes(texPassword.Text.Trim()));  
    string resultPass = System.Text.UTF8Encoding.Unicode.GetString(by);  
    conn.ConnectionString=strConn;  
    SqlCommand comm = new SqlCommand();  
    string name = texName.Text.Trim().ToString();  
    comm.CommandText="select Ruser_pwd,Ruser_nm from Ruser where Accountno = @name";  
    comm.Parameters.Add("@name",SqlDbType.NVarChar,40);  
    comm.Parameters["@name"].Value=name;  
    try  
    {       
     conn.Open();  
     comm.Connection=conn;  
     SqlDataReader dr=comm.ExecuteReader();  
     if(dr.Read())  
     {  
      //用户存在，对密码进行检查  
      if(dr.GetValue(0).Equals(resultPass))  
      {  
       string user_name=dr.GetValue(1).ToString();  
       string user_Accountno=texName.Text.Trim();  
       Session["logon_name"]=user_name;  
       Session["logon_Accountno"]=user_Accountno;  
       //登录成功，进行页面导向  
  
      }  
      else  
      {  
       this.RegisterStartupScript("wp","<mce:script language='javascript'><!--  
alert('密码错误，请检查。')  
// --></mce:script>");  
      }  
        
     }  
     else  
     {  
      this.RegisterStartupScript("nu","<mce:script language=javascript><!--  
alert('用户名不存在，请检查。')  
// --></mce:script>");  
     }  
    }  
    catch(Exception exec)  
    {   
     this.RegisterStartupScript("wc","<mce:script language=javascript><!--  
alert('网络连接有异，请稍后重试。')  
// --></mce:script>");  
    }   
    finally  
    {  
     conn.Close();  
    }  
   }  
}  

【方法三】
一、C# MD5-16位加密实例,32位加密实例(两种方法)

环境：vs.net2005/sql server2000/xp测试通过
1.MD5　16位加密实例

[c-sharp] view plain copy
public string md5(string str,int code)   
 {   
   if(code==16) //16位MD5加密（取32位加密的9~25字符）   
  {   
      return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,"MD5").ToLower().Substring(8,16) ;   
  }    
  else//32位加密   
  {   
      return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,"MD5").ToLower();   
  }    
}   

二、首先在界面中引入：using System.Web.Security;

假设密码对话框名字password，对输入的密码加密后存入变量pwd中，语句如下：

string pwd = FormsAuthentication.HashPasswordForStoringInConfigFile(password.Text, "MD5");

如果要录入则录入pwd，这样数据库实际的密码为202*****等乱码了。

如果登录查询则要：

select username,password from users where username='"+ UserName.Text +"' and password='"+ pwd +"'

因为MD5不能解密，只能把原始密码加密后与数据库中加密的密码比较

三、C# MD5 加密方法 16位或32位

[c-sharp] view plain copy
public string md5(string str,int code)   
 {   
   if(code==16) //16位MD5加密（取32位加密的9~25字符）   
  {   
      return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,"MD5").ToLower().Substring(8,16) ;   
  }    
  else//32位加密   
  {   
      return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,"MD5").ToLower();   
  }    
}   

四、做一个网站时，必然涉及用户登录，用户登录必然涉及密码，密码必然涉及安全，安全必然涉及加密。
加密现时最流行也是据说最安全的算法是MD5算法，MD5是一种不可逆的算法，也就是明文经过加密后，根据加密过的密文无法还原出明文来。
目前有好多网站专搞MD5破密，百度上搜一下MD5就搜出一大堆了，今天早上无聊试了几个破密网站，6位以内纯数字密码的MD5密文可以还原出明文，长点的或带字符的就不行了。他们是采用穷举对比的，就是说把收录到的明文和密文放到数据库里，通过密文的对比来确定明文，毕竟收录的数据有限，所以破解的密码很有限。
扯远了，搞破密MD5需要大量的MONEY，因为要一个运算得超快的计算机和一个查找性能超好的数据库和超大的数据库收录。但搞加密就比较简单。以下是我用C#写的一个MD5加密的方法，用到.NET中的方法，通过MD5_APP.StringToMD5(string str, int i)可以直接调用：

[c-sharp] view plain copy
public class MD5_APP  
{  
 public MD5_APP()  
 {  
       
 }  
  
    public static string StringToMD5(string str, int i)  
    {  
        //获取要加密的字段，并转化为Byte[]数组  
        byte[] data = System.Text.Encoding.Unicode.GetBytes(str.ToCharArray());  
        //建立加密服务  
        System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();  
        //加密Byte[]数组  
        byte[] result = md5.ComputeHash(data);  
        //将加密后的数组转化为字段  
        if (i == 16 && str != string.Empty)  
        {  
            return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5").ToLower().Substring(8, 16);  
        }  
        else if (i == 32 && str != string.Empty)  
        {  
            return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5").ToLower();  
        }  
        else  
        {  
            switch (i)  
            {  
                case 16: return "000000000000000";  
                case 32: return "000000000000000000000000000000";  
                default: return "请确保调用函数时第二个参数为16或32";  
            }  
  
        }  
    }  

---------------------第2组----------------------

【一、使用标准库加密】

[c-sharp] view plain copy
using System;  
using System.Text;  
using System.Security.Cryptography;  
  
namespace ConsoleApplication3  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            string inStr;  
            inStr = "WONSOFT";  
            inStr += "/xa3/xac/xa1/xa3";  
            inStr += "fdjf,jkgfkl";  
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();  
            byte[] InBytes = Encoding.GetEncoding("GB2312").GetBytes(inStr);  
            byte[] OutBytes= md5.ComputeHash(InBytes);  
            string OutString = "";  
            for (int i = 0; i < OutBytes.Length; i++)  
            {  
                OutString += OutBytes[i].ToString("x2");  
            }  
            Console.WriteLine(OutString);  
        }  
    }  
}   

【二、ASP.NET专用加密方法】

[c-sharp] view plain copy
// code 为加密位数，16和32   
public static string Md5(string str, int code)   
        {   
            //str = System.Web.HttpUtility.UrlEncode(str);   
            if (code == 16) //16位MD5加密（取32位加密的9~25字符）   
            {   
                return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5").ToLower().Substring(8, 16);   
            }   
            else//32位加密   
            {   
                return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5").ToLower();   
            }   

【三、MSDN】

[c-sharp] view plain copy
/// <summary>   
/// MD5加密   
/// </summary>   
/// <param name="str"></param>   
/// <returns></returns>   
public static string Md5(string str)   
{   
    // Create a new instance of the MD5CryptoServiceProvider object.   
    MD5 md5Hasher = MD5.Create();   
    // Convert the input string to a byte array and compute the hash.   
    byte[] data = md5Hasher.ComputeHash(Encoding.GetEncoding("UTF-8").GetBytes(str));   
   // return BitConverter.ToString(data);//可以直接使用这个方法   
   //  Create a new Stringbuilder to collect the bytes   
   //  and create a string.   
    StringBuilder sBuilder = new StringBuilder();   
    // Loop through each byte of the hashed data   
    // and format each one as a hexadecimal string.   
    for (int i = 0; i < data.Length; i++)   
    {   
        sBuilder.Append(data.ToString("x2"));   
    }   
    // Return the hexadecimal string.   
    return sBuilder.ToString();   
}   
}   

【四、使用淘宝API】

[c-sharp] view plain copy
/// <summary>   
    /// MD5加密并输出十六进制字符串   
    /// </summary>   
    /// <param name="str"></param>   
    /// <returns></returns>   
    public static string Md5Hex(string str)   
    {   
        string dest = "";   
        //实例化一个md5对像   
        MD5 md5 = MD5.Create();   
        // 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择　   
        byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(str));   
        // 通过使用循环，将字节类型的数组转换为字符串，此字符串是常规字符格式化所得   
        for (int i = 0; i < s.Length; i++)   
        {   
            // 将得到的字符串使用十六进制类型格式。格式后的字符是大写的字母   
            if (s < 16)   
            {   
                dest = dest + "0" + s.ToString("X");   
            }   
            else   
            {   
                dest = dest + s.ToString("X");   
            }   
        }   
        return dest;   
    }   

【五、自己实现MD5类】

[c-sharp] view plain copy
using System;   
using System.Text;   
namespace Encrypter   
{   
    /// <summary>   
    /// Summary description for MD5.   
    /// </summary>   
    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 < 0 || 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 < 0 || 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 < lMessageLength)   
            {   
                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 <= 3; 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 <= 30; i++)   
            {   
                m_lOnBits = Convert.ToInt64(Math.Pow(2, i + 1) - 1);   
                m_l2Power = 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 < x.Length; k += 16)   
            {   
                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(ref b, 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;   
        }   
    }   
}   

注：以上3、4中对于中文有编码问题，上面的案例为UTF-8编码，2中其实也有编码的问题，但是那个主要是与当前页面的编码有关系，即使用默认编码的方式。

0 0