MD5加密算法(16位，32位)的C#,VB的实现

以下为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;
  }
  }
}


以下为MD5算法用VB的实现
//MD5.vb
//MD5 16-bit,32-bits algorithm implemented in C#
Namespace Encrypter


    Public Class MD5
        Private Const BITS_TO_A_BYTE As Integer = 8
        Private Const BYTES_TO_A_WORD As Integer = 4
        Private Const BITS_TO_A_WORD As Integer = 32


        Private Shared m_lOnBits(30) As Long
        Private Shared m_l2Power(30) As Long


        Public Shared Function LShift(ByVal lValue As Long, ByVal iShiftBits As Integer) As Long
            If iShiftBits = 0 Then
                LShift = lValue
                Exit Function
            ElseIf iShiftBits = 31 Then
                If lValue And 1 Then
                    LShift = &H80000000
                Else
                    LShift = 0
                End If
                Exit Function
            ElseIf iShiftBits < 0 Or iShiftBits > 31 Then
                Err.Raise(6)
            End If


            If (lValue And m_l2Power(31 - iShiftBits)) Then
                LShift = ((lValue And m_lOnBits(31 - (iShiftBits + 1))) * m_l2Power(iShiftBits)) Or &H80000000
            Else
                LShift = ((lValue And m_lOnBits(31 - iShiftBits)) * m_l2Power(iShiftBits))
            End If
        End Function


        Public Shared Function RShift(ByVal lValue As Long, ByVal iShiftBits As Integer) As Long
            If iShiftBits = 0 Then
                RShift = lValue
                Exit Function
            ElseIf iShiftBits = 31 Then
                If lValue And &H80000000 Then
                    RShift = 1
                Else
                    RShift = 0
                End If
                Exit Function
            ElseIf iShiftBits < 0 Or iShiftBits > 31 Then
                Err.Raise(6)
            End If


            RShift = (lValue And &H7FFFFFFE) / m_l2Power(iShiftBits)


            If (lValue And &H80000000) Then
                RShift = (RShift Or (&H40000000 / m_l2Power(iShiftBits - 1)))
            End If
        End Function


        Public Shared Function RotateLeft(ByVal lValue As Long, ByVal iShiftBits As Integer) As Long
            RotateLeft = LShift(lValue, iShiftBits) Or RShift(lValue, (32 - iShiftBits))
        End Function


        Private Shared Function AddUnsigned(ByVal lX As Long, ByVal lY As Long) As Long
            Dim lX4 As Long
            Dim lY4 As Long
            Dim lX8 As Long
            Dim lY8 As Long
            Dim lResult As Long


            lX8 = lX And &H80000000
            lY8 = lY And &H80000000
            lX4 = lX And &H40000000
            lY4 = lY And &H40000000


            lResult = (lX And &H3FFFFFFF) + (lY And &H3FFFFFFF)


            If lX4 And lY4 Then
                lResult = lResult Xor &H80000000 Xor lX8 Xor lY8
            ElseIf lX4 Or lY4 Then
                If lResult And &H40000000 Then
                    lResult = lResult Xor &HC0000000 Xor lX8 Xor lY8
                Else
                    lResult = lResult Xor &H40000000 Xor lX8 Xor lY8
                End If
            Else
                lResult = lResult Xor lX8 Xor lY8
            End If


            AddUnsigned = lResult
        End Function


        Private Shared Function md5_F(ByVal x As Long, ByVal y As Long, ByVal z As Long) As Long
            md5_F = (x And y) Or ((Not x) And z)
        End Function


        Private Shared Function md5_G(ByVal x As Long, ByVal y As Long, ByVal z As Long) As Long
            md5_G = (x And z) Or (y And (Not z))
        End Function


        Private Shared Function md5_H(ByVal x As Long, ByVal y As Long, ByVal z As Long) As Long
            md5_H = (x Xor y Xor z)
        End Function


        Private Shared Function md5_I(ByVal x As Long, ByVal y As Long, ByVal z As Long) As Long
            md5_I = (y Xor (x Or (Not z)))
        End Function


        Private Shared Sub md5_FF(ByRef a As Long, ByVal b As Long, ByVal c As Long, ByVal d As Long, ByVal x As Long, ByVal s As Long, ByVal ac As Long)
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac))
            a = RotateLeft(a, s)
            a = AddUnsigned(a, b)
        End Sub


        Private Shared Sub md5_GG(ByRef a As Long, ByVal b As Long, ByVal c As Long, ByVal d As Long, ByVal x As Long, ByVal s As Long, ByVal ac As Long)
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac))
            a = RotateLeft(a, s)
            a = AddUnsigned(a, b)
        End Sub


        Private Shared Sub md5_HH(ByRef a As Long, ByVal b As Long, ByVal c As Long, ByVal d As Long, ByVal x As Long, ByVal s As Long, ByVal ac As Long)
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac))
            a = RotateLeft(a, s)
            a = AddUnsigned(a, b)
        End Sub


        Private Shared Sub md5_II(ByRef a As Long, ByVal b As Long, ByVal c As Long, ByVal d As Long, ByVal x As Long, ByVal s As Long, ByVal ac As Long)
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac))
            a = RotateLeft(a, s)
            a = AddUnsigned(a, b)
        End Sub


        Private Shared Function ConvertToWordArray(ByVal sMessage As String)
            Dim lMessageLength As Integer
            Dim lNumberOfWords As Integer
            Dim lWordArray() As Long
            Dim lBytePosition As Integer
            Dim lByteCount As Integer
            Dim lWordCount As Integer


            Const MODULUS_BITS As Long = 512
            Const CONGRUENT_BITS As Long = 448


            lMessageLength = Len(sMessage)


            lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD)
            ReDim lWordArray(lNumberOfWords - 1)


            lBytePosition = 0
            lByteCount = 0
            Do Until lByteCount >= lMessageLength
                lWordCount = lByteCount / BYTES_TO_A_WORD
                lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE
                lWordArray(lWordCount) = lWordArray(lWordCount) Or LShift(Asc(Mid(sMessage, lByteCount + 1, 1)), lBytePosition)
                lByteCount = lByteCount + 1
            Loop


            lWordCount = lByteCount / BYTES_TO_A_WORD
            lBytePosition = (lByteCount Mod BYTES_TO_A_WORD) * BITS_TO_A_BYTE


            lWordArray(lWordCount) = lWordArray(lWordCount) Or LShift(&H80, lBytePosition)


            lWordArray(lNumberOfWords - 2) = LShift(lMessageLength, 3)
            lWordArray(lNumberOfWords - 1) = RShift(lMessageLength, 29)


            ConvertToWordArray = lWordArray
        End Function


        Public Shared Function WordToHex(ByVal lValue As Long)
            Dim lByte As Long
            Dim lCount As Long


            For lCount = 0 To 3
                lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) And m_lOnBits(BITS_TO_A_BYTE - 1)
                WordToHex = WordToHex & Right("0" & Hex(lByte), 2)
            Next
        End Function


        Public Shared Function Encrypt(ByVal sMessage As String, ByVal stype As Integer)
            m_lOnBits(0) = CLng(1)
            m_lOnBits(1) = CLng(3)
            m_lOnBits(2) = CLng(7)
            m_lOnBits(3) = CLng(15)
            m_lOnBits(4) = CLng(31)
            m_lOnBits(5) = CLng(63)
            m_lOnBits(6) = CLng(127)
            m_lOnBits(7) = CLng(255)
            m_lOnBits(8) = CLng(511)
            m_lOnBits(9) = CLng(1023)
            m_lOnBits(10) = CLng(2047)
            m_lOnBits(11) = CLng(4095)
            m_lOnBits(12) = CLng(8191)
            m_lOnBits(13) = CLng(16383)
            m_lOnBits(14) = CLng(32767)
            m_lOnBits(15) = CLng(65535)
            m_lOnBits(16) = CLng(131071)
            m_lOnBits(17) = CLng(262143)
            m_lOnBits(18) = CLng(524287)
            m_lOnBits(19) = CLng(1048575)
            m_lOnBits(20) = CLng(2097151)
            m_lOnBits(21) = CLng(4194303)
            m_lOnBits(22) = CLng(8388607)
            m_lOnBits(23) = CLng(16777215)
            m_lOnBits(24) = CLng(33554431)
            m_lOnBits(25) = CLng(67108863)
            m_lOnBits(26) = CLng(134217727)
            m_lOnBits(27) = CLng(268435455)
            m_lOnBits(28) = CLng(536870911)
            m_lOnBits(29) = CLng(1073741823)
            m_lOnBits(30) = CLng(2147483647)


            m_l2Power(0) = CLng(1)
            m_l2Power(1) = CLng(2)
            m_l2Power(2) = CLng(4)
            m_l2Power(3) = CLng(8)
            m_l2Power(4) = CLng(16)
            m_l2Power(5) = CLng(32)
            m_l2Power(6) = CLng(64)
            m_l2Power(7) = CLng(128)
            m_l2Power(8) = CLng(256)
            m_l2Power(9) = CLng(512)
            m_l2Power(10) = CLng(1024)
            m_l2Power(11) = CLng(2048)
            m_l2Power(12) = CLng(4096)
            m_l2Power(13) = CLng(8192)
            m_l2Power(14) = CLng(16384)
            m_l2Power(15) = CLng(32768)
            m_l2Power(16) = CLng(65536)
            m_l2Power(17) = CLng(131072)
            m_l2Power(18) = CLng(262144)
            m_l2Power(19) = CLng(524288)
            m_l2Power(20) = CLng(1048576)
            m_l2Power(21) = CLng(2097152)
            m_l2Power(22) = CLng(4194304)
            m_l2Power(23) = CLng(8388608)
            m_l2Power(24) = CLng(16777216)
            m_l2Power(25) = CLng(33554432)
            m_l2Power(26) = CLng(67108864)
            m_l2Power(27) = CLng(134217728)
            m_l2Power(28) = CLng(268435456)
            m_l2Power(29) = CLng(536870912)
            m_l2Power(30) = CLng(1073741824)




            Dim x() As Long
            Dim k As Integer
            Dim AA As Integer
            Dim BB As Integer
            Dim CC As Integer
            Dim DD As Integer
            Dim a As Integer
            Dim b As Integer
            Dim c As Integer
            Dim d As Integer


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


            x = ConvertToWordArray(sMessage)


            a = &H67452301
            b = &HEFCDAB89
            c = &H98BADCFE
            d = &H10325476


            For k = 0 To UBound(x) Step 16
                AA = a
                BB = b
                CC = c
                DD = d


                md5_FF(a, b, c, d, x(k + 0), S11, &HD76AA478)
                md5_FF(d, a, b, c, x(k + 1), S12, &HE8C7B756)
                md5_FF(c, d, a, b, x(k + 2), S13, &H242070DB)
                md5_FF(b, c, d, a, x(k + 3), S14, &HC1BDCEEE)
                md5_FF(a, b, c, d, x(k + 4), S11, &HF57C0FAF)
                md5_FF(d, a, b, c, x(k + 5), S12, &H4787C62A)
                md5_FF(c, d, a, b, x(k + 6), S13, &HA8304613)
                md5_FF(b, c, d, a, x(k + 7), S14, &HFD469501)
                md5_FF(a, b, c, d, x(k + 8), S11, &H698098D8)
                md5_FF(d, a, b, c, x(k + 9), S12, &H8B44F7AF)
                md5_FF(c, d, a, b, x(k + 10), S13, &HFFFF5BB1)
                md5_FF(b, c, d, a, x(k + 11), S14, &H895CD7BE)
                md5_FF(a, b, c, d, x(k + 12), S11, &H6B901122)
                md5_FF(d, a, b, c, x(k + 13), S12, &HFD987193)
                md5_FF(c, d, a, b, x(k + 14), S13, &HA679438E)
                md5_FF(b, c, d, a, x(k + 15), S14, &H49B40821)


                md5_GG(a, b, c, d, x(k + 1), S21, &HF61E2562)
                md5_GG(d, a, b, c, x(k + 6), S22, &HC040B340)
                md5_GG(c, d, a, b, x(k + 11), S23, &H265E5A51)
                md5_GG(b, c, d, a, x(k + 0), S24, &HE9B6C7AA)
                md5_GG(a, b, c, d, x(k + 5), S21, &HD62F105D)
                md5_GG(d, a, b, c, x(k + 10), S22, &H2441453)
                md5_GG(c, d, a, b, x(k + 15), S23, &HD8A1E681)
                md5_GG(b, c, d, a, x(k + 4), S24, &HE7D3FBC8)
                md5_GG(a, b, c, d, x(k + 9), S21, &H21E1CDE6)
                md5_GG(d, a, b, c, x(k + 14), S22, &HC33707D6)
                md5_GG(c, d, a, b, x(k + 3), S23, &HF4D50D87)
                md5_GG(b, c, d, a, x(k + 8), S24, &H455A14ED)
                md5_GG(a, b, c, d, x(k + 13), S21, &HA9E3E905)
                md5_GG(d, a, b, c, x(k + 2), S22, &HFCEFA3F8)
                md5_GG(c, d, a, b, x(k + 7), S23, &H676F02D9)
                md5_GG(b, c, d, a, x(k + 12), S24, &H8D2A4C8A)


                md5_HH(a, b, c, d, x(k + 5), S31, &HFFFA3942)
                md5_HH(d, a, b, c, x(k + 8), S32, &H8771F681)
                md5_HH(c, d, a, b, x(k + 11), S33, &H6D9D6122)
                md5_HH(b, c, d, a, x(k + 14), S34, &HFDE5380C)
                md5_HH(a, b, c, d, x(k + 1), S31, &HA4BEEA44)
                md5_HH(d, a, b, c, x(k + 4), S32, &H4BDECFA9)
                md5_HH(c, d, a, b, x(k + 7), S33, &HF6BB4B60)
                md5_HH(b, c, d, a, x(k + 10), S34, &HBEBFBC70)
                md5_HH(a, b, c, d, x(k + 13), S31, &H289B7EC6)
                md5_HH(d, a, b, c, x(k + 0), S32, &HEAA127FA)
                md5_HH(c, d, a, b, x(k + 3), S33, &HD4EF3085)
                md5_HH(b, c, d, a, x(k + 6), S34, &H4881D05)
                md5_HH(a, b, c, d, x(k + 9), S31, &HD9D4D039)
                md5_HH(d, a, b, c, x(k + 12), S32, &HE6DB99E5)
                md5_HH(c, d, a, b, x(k + 15), S33, &H1FA27CF8)
                md5_HH(b, c, d, a, x(k + 2), S34, &HC4AC5665)


                md5_II(a, b, c, d, x(k + 0), S41, &HF4292244)
                md5_II(d, a, b, c, x(k + 7), S42, &H432AFF97)
                md5_II(c, d, a, b, x(k + 14), S43, &HAB9423A7)
                md5_II(b, c, d, a, x(k + 5), S44, &HFC93A039)
                md5_II(a, b, c, d, x(k + 12), S41, &H655B59C3)
                md5_II(d, a, b, c, x(k + 3), S42, &H8F0CCC92)
                md5_II(c, d, a, b, x(k + 10), S43, &HFFEFF47D)
                md5_II(b, c, d, a, x(k + 1), S44, &H85845DD1)
                md5_II(a, b, c, d, x(k + 8), S41, &H6FA87E4F)
                md5_II(d, a, b, c, x(k + 15), S42, &HFE2CE6E0)
                md5_II(c, d, a, b, x(k + 6), S43, &HA3014314)
                md5_II(b, c, d, a, x(k + 13), S44, &H4E0811A1)
                md5_II(a, b, c, d, x(k + 4), S41, &HF7537E82)
                md5_II(d, a, b, c, x(k + 11), S42, &HBD3AF235)
                md5_II(c, d, a, b, x(k + 2), S43, &H2AD7D2BB)
                md5_II(b, c, d, a, x(k + 9), S44, &HEB86D391)
                Console.WriteLine(a)
                a = AddUnsigned(a, AA)
                b = AddUnsigned(b, BB)
                c = AddUnsigned(c, CC)
                d = AddUnsigned(d, DD)
            Next


            If stype = 32 Then
                Encrypt = LCase(WordToHex(a) & WordToHex(b) & WordToHex(c) & WordToHex(d))
            Else
                Encrypt = LCase(WordToHex(b) & WordToHex(c))
            End If
        End Function


    End Class


End Namespace