网络上搜索很多MD5加密代码,输入\"wuxiaomei*\",你会发现系统出错所以还是只能自己修改
public mymd5( str, code)
{
(code16) //16位MD5加密(取32位加密9~25)
{
.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,\"MD5\").ToLower.Sub(8,16) ;
}
//32位加密
{
.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,\"MD5\").ToLower;
}
}



网络上MD5常用类加密算法代码如下

using ;
using .Text;



MY_WORKSPACE
{
public MD5
{
const BITS_TO_A_BYTE = 8;
const BYTES_TO_A_WORD = 4;
const BITS_TO_A_WORD = 32;
private long m_lOnBits = long[30 + 1];
private long m_l2Power = long[30 + 1];

private long LSht(long lValue, long iShtBits)
{
long LSht = 0;
(iShtBits 0)
{
LSht = lValue;
LSht;
}

{
(iShtBits 31)
{
(Convert.ToBoolean(lValue & 1))
{
LSht = 0x80000000;
}

{
LSht = 0;
}
LSht;
}

{
(iShtBits < 0 || iShtBits > 31)
{
// Err.Raise 6;
}
}
}

(Convert.ToBoolean((lValue & m_l2Power[31 - iShtBits])))
{
LSht = ((lValue & m_lOnBits[31 - (iShtBits + 1)]) * m_l2Power[iShtBits]) | 0x80000000;
}

{
LSht = ((lValue & m_lOnBits[31 - iShtBits]) * m_l2Power[iShtBits]); [Page]
}

LSht;
}

private long RSht(long lValue, long iShtBits)
{
long RSht = 0;
(iShtBits 0)
{
RSht = lValue;
RSht;
}

{
(iShtBits 31)
{
(Convert.ToBoolean(lValue & 0x80000000))
{
RSht = 1;
}

{
RSht = 0;
}
RSht;
}

{
(iShtBits < 0 || iShtBits > 31)
{
// Err.Raise 6;
}
}
}

RSht = (lValue & 0x7FFFFFFE) / m_l2Power[iShtBits];

(Convert.ToBoolean((lValue & 0x80000000)))
{
RSht = (RSht | (0x40000000 / m_l2Power[iShtBits - 1]));
}

RSht;
}

private long RotateLeft(long lValue, long iShtBits)
{
long RotateLeft = 0;
RotateLeft = LSht(lValue, iShtBits) | RSht(lValue, (32 - iShtBits));
RotateLeft;
}

private 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);
(Convert.ToBoolean(lX4 & lY4))
{
lResult = lResult ^ 0x80000000 ^ lX8 ^ lY8;
}
(Convert.ToBoolean(lX4 | lY4)) [Page]
{
(Convert.ToBoolean(lResult & 0x40000000))
{
lResult = lResult ^ 0xC0000000 ^ lX8 ^ lY8;
}

{
lResult = lResult ^ 0x40000000 ^ lX8 ^ lY8;
}
}

{
lResult = lResult ^ lX8 ^ lY8;
}
AddUnsigned = lResult;
AddUnsigned;
}

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

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

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

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

private 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 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 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 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)); [Page]
a = RotateLeft(a, s);
a = AddUnsigned(a, b);
}

private long ConvertToWordArray( sMessage)
{
long ConvertToWordArray = null;
lMessageLength = 0;
lNumberOfWords = 0;
long lWordArray = null;
lBytePosition = 0;
lByteCount = 0;
lWordCount = 0;

const MODULUS_BITS = 512;
const 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 = 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] | LSht(Convert.ToByte(sMessage.Sub(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] | LSht(0x80, lBytePosition);
lWordArray[lNumberOfWords - 2] = LSht(lMessageLength, 3);


lWordArray[lNumberOfWords - 1] = RSht(lMessageLength, 29);
ConvertToWordArray = lWordArray;

ConvertToWordArray;
}

private WordToHex(long lValue)
{
WordToHex = \"\";
long lByte = 0;
lCount = 0;
for (lCount = 0; lCount <= 3; lCount)
{
lByte = RSht(lValue, lCount * BITS_TO_A_BYTE) & m_lOnBits[BITS_TO_A_BYTE - 1];
WordToHex = WordToHex + ((\"0\" + ToHex(lByte)).Sub((\"0\" + ToHex(lByte)).Length - 2));
}
WordToHex;
}

private ToHex(long dec) [Page]
{
strhex = \"\";
while (dec > 0)
{
strhex = tohex(dec % 16) + strhex;
dec = dec / 16;
}
strhex;
}

private tohex(long hex)
{
strhex = \"\";
switch (hex)
{
10: strhex = \"a\"; ;
11: strhex = \"b\"; ;
12: strhex = \"c\"; ;
13: strhex = \"d\"; ;
14: strhex = \"e\"; ;
15: strhex = \"f\"; ;
default: strhex = hex.; ;
}
strhex;
}


public Encrypt( sMessage, stype)
{
MD5 = \"\";

for ( 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;
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 S11 = 7;
const S12 = 12;
const S13 = 17;
const S14 = 22;
const S21 = 5;
const S22 = 9;
const S23 = 14;
const S24 = 20;
const S31 = 4;
const S32 = 11;
const S33 = 16;
const S34 = 23;
const S41 = 6;
const S42 = 10;
const S43 = 15;
const 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; [Page]
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); [Page]
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); [Page]
}

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

{
MD5 = ((WordToHex(b)) + (WordToHex(c))).ToLower;
}
MD5;
}
}
}