【第22期】观点:IT 行业加班,到底有没有价值?

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

转载 2006年06月25日 11:23:00
以下为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 VB
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
举报

相关文章推荐

Android、Java中16位及32位MD5加密算法工具类,直接使用!!!

在平时开发过程中,MD5加密是一个比较常用的算法,最常见的使用场景就是在帐号注册时,用户输入的密码经MD5加密后,传输至服务器保存起来。虽然MD5加密经常用,但是MD5的加密原理真说不上来,对MD5的...

java md5 加密 32位/16位

/* * 记得以前写过,找不到了…… * 百度的空间内容搜索还是不太理想…… * 再写一次吧…… */ import java.security.MessageDigest; public class Md5 { /** * md5加密方法 * @author: zheng...

程序员升职加薪指南!还缺一个“证”!

CSDN出品,立即查看!

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

以下为MD5算法用c#的实现//MD5.cs//MD5 16-bit,32-bits algorithm implemented in C#using System;using System.Text...

MD5算法加密(16位、32位、64位)

package com.util; import java.io.UnsupportedEncodingException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException;...

C#16位MD5加密算法

MD5 = LCase(WordToHex(a) & WordToHex(b) & WordToHex(c) & WordToHex(d)) '32位      MD5 = LCase(WordTo...
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)