MD5算法：
using System;
using System.Text;
namespace BaseStationPDA
{
//// <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.Sub
string( 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 ) ).Sub
string( ( "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( );
}
//
MD5=MD5.Replace( "0", "a" );
//
MD5=MD5.Replace( "1", "b" );
//
MD5=MD5.Replace( "2", "cs" );
//
MD5=MD5.Replace( "3", "d" );
//
MD5=MD5.Replace( "4", "e" );
//
MD5=MD5.Replace( "5", "f" );
//
MD5=MD5.Replace( "6", "k" );
//
MD5=MD5.Replace( "7", "s" );
////
MD5=MD5.Replace( "8", "r" );
//
MD5=MD5.Replace( "9", "ip" );
//
MD5=MD5.Replace( "j", "8" );
//
MD5=MD5.Replace( "o", "3" );
////
MD5=MD5.Replace( "a", "04" );
//
MD5=MD5.Replace( "m", "3" );
//
MD5=MD5.Replace( "x", "67" );
//
MD5=MD5.Replace( "p", "23" );
//
MD5=MD5.Replace( "g", "7" );
//自已再加上个尾缀别人根本解不出来
return MD5;
}
}
}
( 2 )倒序加1与顺序减1
public static
string DecryptStr( string rs ) //顺序减1解码
{
byte[] by=new byte[rs.Length];
for( int i=0;
i<=rs.Length-1;
i++ )
{
by[i]=( byte )( ( byte )rs[i]-1 );
}
rs="";
for( int i=by.Length-1;
i>=0;
i-- )
{
rs+=( ( char )by[i] ).ToString( );
}
return rs;
}
public static
string EncryptStr( string rs ) //倒序加1加密
{
byte[] by=new byte[rs.Length];
for( int i=0;
i<=rs.Length-1;
i++ )
{
by[i]=( byte )( ( byte )rs[i]+1 );
}
rs="";
for( int i=by.Length-1;
i>=0;
i-- )
{
rs+=( ( char )by[i] ).ToString( );
}
return rs;
}
( 3 )又一种不同的密钥
public static
string EncryptMethod( string rs ) //加密
{
byte[] desKey = new byte[]
{
0x16, 0x09, 0x14, 0x15, 0x07, 0x01, 0x05, 0x08
}
;
byte[] desIV = new byte[]
{
0x16, 0x09, 0x14, 0x15, 0x07, 0x01, 0x05, 0x08
}
;
DESCryptoServiceProvider des = new DESCryptoServiceProvider( );
try
{
byte[] inputByteArray = Encoding.Default.GetBytes( rs );
//byte[] inputByteArray=Encoding.Unicode.GetBytes( rs );
des.Key = desKey;
// ASCIIEncoding.ASCII.GetBytes( sKey );
des.IV = desIV;
//ASCIIEncoding.ASCII.GetBytes( sKey );
MemoryStream ms = new MemoryStream( );
CryptoStream cs = new CryptoStream( ms, des.CreateEncryptor( ),
CryptoStreamMode.Write );
//Write the byte array
into the crypto stream
//( It will end up in the memory stream )
cs.Write( inputByteArray, 0, inputByteArray.Length );
cs.FlushFinalBlock( );
//Get the data back from the memory stream, and
into a
string
StringBuilder ret = new StringBuilder( );
foreach( byte b in ms.ToArray( ) )
{
//Format as hex
ret.AppendFormat( "
{
0:X2
}
", b );
}
ret.ToString( );
return ret.ToString( );
}
catch
{
return rs;
}
finally
{
des = null;
}
}
public static
string DecryptMethod( string rs )
//解密
{
byte[] desKey = new byte[]
{
0x16, 0x09, 0x14, 0x15, 0x07, 0x01, 0x05, 0x08
}
;
byte[] desIV = new byte[]
{
0x16, 0x09, 0x14, 0x15, 0x07, 0x01, 0x05, 0x08
}
;
DESCryptoServiceProvider des = new DESCryptoServiceProvider( );
try
{
//Put the input
string
into the byte array
byte[] inputByteArray = new byte[rs.Length / 2];
for( int x = 0;
x < rs.Length / 2;
x++ )
{
int i = ( Convert.ToInt32( rs.Sub
string( x * 2, 2 ), 16 ) );
inputByteArray[x] = ( byte )i;
}
des.Key = desKey;
//ASCIIEncoding.ASCII.GetBytes( sKey );
des.IV = desIV;
//ASCIIEncoding.ASCII.GetBytes( sKey );
MemoryStream ms = new MemoryStream( );
CryptoStream cs = new CryptoStream( ms, des.CreateDecryptor( ),CryptoStreamMode.Write );
//Flush the data through the crypto stream
into the memory stream
cs.Write( inputByteArray, 0, inputByteArray.Length );
cs.FlushFinalBlock( );
//Get the decrypted data back from the memory stream
StringBuilder ret = new StringBuilder( );
return System.Text.Encoding.Default.GetString( ms.ToArray( ) );
}
catch
{
return rs;
}
finally
{
des = null;
}
}
有些加密的还可以起到别的作用,如上次我在PDA上要post图片和一些说明文字到web服务器上中文的处理就是用了一些小巧的加密算法,因为.net的mobile上不支持一些特殊的算法(支持MD5但MD5不可解密的)上面写的两种都不支持所以只好另写：
private
string aa( string bb )
{
byte[] by=new byte[bb.Length];
by=System.Text.Encoding.UTF8.GetBytes( bb );
string r=Convert.ToBase64String( by );
return r;
}
private
string bb( string aa )
{
byte[] by=Convert.FromBase64String( aa );
string r=Encoding.UTF8.GetString( by );
return r;
}
