设为首页
给我留言
首页       关于蓬缘    克隆建站    模版建站    建站流程    建站疑虑    支付方式    网站推广    网站优化    建站学院    联系我们    
蓬缘网络技术工作室真心为您服务!霸州网站建设 + 霸州网页设计 + 霸州企业建站 + 霸州FLASH设计 + 霸州网站开发 + 平面设计,专业技术人员一对一服务让建站更加专业更加放心……二十四小时服务热线: 15932615201 13810319167。欢迎来电咨询……霸州网站建设工作室|霸州网站制作|霸州建站|霸州网站改版|霸州企业建站|霸州专业建站|蓬缘网络技术工作室 - 我要网站 - http://www.woyaowangzhan.com……霸州蓬缘网络技术工作室是专业的建站团队,提供专业的霸州建站服务:1、霸州专业网站建设(霸州网站设计)2、霸州网站推广(百度、Google、搜狐、阿里巴巴等)3、霸州网站优化(SEO、百度推广优化)4、霸州域名注册(.com/.cn/.net等)5、霸州虚拟主机(ASP、.net等)6、霸州政府建站7、霸州门户网站…… 现在时间是
建站学堂
 
MD5加密算法(16位,32位)的C#的实现
[ 2008-9-15 19:41:00 ] 作者: 来源:

  核心提示:...

我们在做数据库系统开发,或者是网站开发时,经常会对一些重要的数据进行加密操作,时下流行的加密方式有很多,但最为常见的就是MD5加密了,虽然VisualStudio2005中已经含有了MD5加密的方法但与之前VB或ASP中使用的MD5加密有一定的出入,结果总是少一位,16位加密结果有时会出现15位,而32位的则是31位,这样就和之前程序开发的加密结果不相符了,做不到通用性很强的作用.


综合上述问题,对原有加密进行了改进.以下为MD5算法用c#的实现
//MD5.cs
//MD5 16-bit,32-bits algorithm implemented in C#

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[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 < 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;
   }
   }
}



 
   建站学堂
  ●  ASP编程技术
  ●  PHP编程技术
  ●  JSP编辑技术
  ●  ASP.NET编程技术
  ●  JAVA软件开发
  ●  C#软件开发
  ●  VB.NET软件开发
   网站推广与营销
  ● 网站备案的9个细节问题
  ● 网上注册一个域名的意义
  ● 网站从建设到运营的5点注意
  ● 8种提高网站ALEXA排名的方法
  ● 搜索引擎之间的4个区别
  ● 网站优化基本搜索引擎优化篇
  ● 点评A8音乐商业模式
  ● 5种不可取的网站推广方法
  ● SNS将成四大门户竞争的关键筹码
  ● 企业整站优化的一些技巧
  ● 马化腾创业三问
  ● 站长们每天都要做的工作
   网站优化与排名
  ● 快速提升访问量的方法
  ● 网站优化关键词工具,优化软件,SEO优化工具,SEO优化软件
  ● 总结四点分享我建站失败的经历
  ● 从达人圈到开心人人首谈SNS域名的选择与定位
  ● 良好心态是站长们成功的关键
  ● 浅谈做冷门站的一些心得体会
  ● 小游戏网站经营最重要的是站在用户的角度创新
  ● 关于网站首页打开速度之我见
  ● 谈一次域名解析出错带来的惨痛代价
  ● 我的地方论坛的建站之路经验总结
  ● 千人站长讲座第46期空姐网军哥谈特色社区运营
  ● 浅谈QQ类网站之站长的出路