Implement the MD5 algorithm fully compatible with ASP in. net (1)

In. net, because. net framework encapsulates common encryption algorithms, it takes only a few lines of code to implement the standard MD5 Algorithm:

Public string Md5 (string strPassword)
{

MD5CryptoServiceProvider hashmd5;
Hashmd5 = new MD5CryptoServiceProvider ();
Return BitConverter. ToString (hashmd5.ComputeHash (Encoding. Default. GetBytes (strPassword). Replace ("-", ""). ToLower ();
}

However, when the encrypted string contains Chinese or other double-byte characters, the results of this algorithm are inconsistent with the MD5 Algorithm currently popular on the Internet, this is mainly because the MD5 encryption algorithm written by ASP is popular on the Internet, which has a defect. It uses the mid function and extracts "characters ", the correct method should be to retrieve bytes. Therefore, when the encrypted string has two-byte characters, the result will be different from the standard MD5 algorithm .. However, in the process of upgrading ASP to the ASP.net system, a large number of previously encrypted ASP passwords have been written to the database. In order to make the new system fully compatible with the original system, therefore, only.. net environment to implement the MD5 algorithm that is exactly the same as the original ASP algorithm. My Implementation ideas are as follows:

1. Use a regular expression to determine whether the string to be encrypted contains dubyte characters.

2. if it contains double-byte characters, call an unmanaged COM component that is consistent with the ASP Algorithm for processing. This component only needs to modify the original ASP encryption algorithm code and add it to VB6 for compilation ).

3. Otherwise, the standard MD5 encryption algorithm of. net will be called directly.

Some may ask why not all COM components are directly called for encryption? This is mainly from the perspective of performance. Because the unmanaged COM component is called,. net needs to generate a proxy class to interact with it, so the performance is far lower than that of. net built-in functions.

The following code is provided:

Original ASP encryption code:

<%

Private Const BITS_TO_A_BYTE = 8
Private Const BYTES_TO_A_WORD = 4
Private Const BITS_TO_A_WORD = 32

Private m_lOnBits (30)
Private m_l2Power (30)

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 (1, 127)
M_lOnBits (7) = CLng (255)
M_lOnBits (8) = CLng (511)
M_lOnBits (9) = CLng (1, 1023)
M_lOnBits (10) = CLng (2047)
M_lOnBits (11) = CLng (4095)
M_lOnBits (12) = CLng (8191)
M_lOnBits (13) = CLng (1, 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 (1, 524287)
M_lOnBits (19) = CLng (1048575)
M_lOnBits (20) = CLng (2097151)
M_lOnBits (21) = CLng (4194303)
M_lOnBits (22) = CLng (1, 8388607)
M_lOnBits (23) = CLng (1, 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 (1, 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)

Private Function LShift (lValue, iShiftBits)
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

Private Function RShift (lValue, iShiftBits)
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 & effecffffffe) \ m_l2Power (iShiftBits)

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

Private Function RotateLeft (lValue, iShiftBits)
RotateLeft = LShift (lValue, iShiftBits) Or RShift (lValue, (32-iShiftBits ))
End Function

Private Function AddUnsigned (lX, lY)
Dim lX4
Dim lY4
Dim lX8
Dim lY8
Dim lResult

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