Implementation of C #, VB of MD5 encryption algorithm (16, 32)

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 {ix (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 {ri = 0;} Return Rshift;} else {ix (iShiftBits <0 | iShiftBits> 31) {// Err.raise 6;}}}

Rshift = (Lvalue & 0x7ffffe) / 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 list) {long address = 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 & 0x3fffff) (Ly & 0x3ffffff); if (convert.toboolean (lx4 & ly4)) {LRESULT = LRESULT ^ 0x80000000 ^ LX8 ^ ly8;} else ket (control.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 = 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, 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 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 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 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

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 strinder = ""; 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; cas 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;} 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 bb = 0; long CC = 0; long DD = 0; long b = 0; long c = 0; long d = 0;

Const Int S11 = 7; 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 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

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, 0x24441453); 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 (Aa) ; B = addunsigned (b, bb); c = addunsigned (c, cc); d = addunsigned (d, dd);}

IF (stype == 32) {md5 = (((WordToHex (a))) (WordTohex (C))) (WordTohex (D))). TOLOWER ();} else {MD5 = ((WordTohex (B)) (WordToHex (C))). TOLOWER ();} Return MD5;}}} The following is the MD5 algorithm for VB implementation //md5.vb/md5 16-bit, 32-Bits Algorithm Implement 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) endiff

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 FunctionPublic 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) endiff

Rshift = (LValue and & H7ffffe) / 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 "AS Long Rotateleft = Lshift (Lvalue, Ishiftbits) or Rshift (Lvalue, (32 - IshiftBits) End Function

Private Shared Function Add (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 & h3ffffff) (Ly and & H3FFFFFF)

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 ifaddunsigned = 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) or (Y AND Z) OR (Y AND ") End Function

Private Shared Function MD5_H (BYVAL X As Long, BYVAL Y AS Long

Private shared function md5_i (byval x ask, 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 (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 (Addunsigned MD5_G (B, C, D), X), AC)) A = Rotateleft (A, S) a = addunsigned (a, b) end subsprivate shared sub md5_hh (byref a as long, byval B As Long, Byval C As Long, Byval D As Long, Byvalx As Long, Byval S as Long, Byval AC AS LONG A = AddunSigned (ADDUNSIGNED (Addunsigned (MD5_H (B, 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) ), lbytecount = lbytecount 1 looplwordcount = lbytecount / bytes_to_a_word lbyteposition = (lbytecount mode_to_a_word) * bits_to_a_byte

LWordArray (lwordcount) = lwordArray (lwordcount) or lshift (& H80, lbyteposition)

LWordArray (lnumberofwords - 2) = lshift (LMESSAGALELENGTH, 3) LWORDARRAY (Lnumberofwords - 1) = Rshift (LMESSAGALELENGTH, 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 SMESSAGER) 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 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 = 21x = 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) 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, 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, & HF429244) 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, & H65559C3) MD5_II (D, A, B, C, X (K 3), S42, & H8F0CC92) 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) NextIf 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