3DES encryption and decryption
Also known as 3DES Triple DES, DES encryption algorithm is a model, which uses three 56-bit key to encrypt the data three times. Data Encryption Standard (DES) encryption standard for the United States is long, which uses symmetric key cryptography, and in 1981 organized as ANSI Specification ANSI X.3.92. DES uses a 56-bit key cryptographic method and a block and in the process of the ciphertext block, the size of the text is divided into 64-bit text block and then encrypted. Compared to the original DES, 3DES is more secure. 3DES (ie, Triple DES) encryption algorithm DES transition to AES (In 1999, NIST will be designated as 3DES encryption standard transition), it is a safer deformation DES. It DES basic module design combined packet by packet encryption algorithm method, which is embodied as follows: Let Ek () and Dk () on behalf of the DES algorithm encryption and decryption, the key K represents the DES algorithm, P represents plaintext, C for dense table, so that, 3DES encryption process is: C = EK3 (DK2 (Ek1 (P))) 3DES decryption process is: P = Dk1 ((EK2 ( Dk3 (C))) specific encryption / decryption process As shown in the using the System; the using the System.Text; the using the System.IO; the using the System.Security.Cryptography; class the Class1 { static void the Main () { Console.WriteLine ( "Encrypt String ..."); txtKey = " tkGGRmBErvc = "; btnKeyGen () ; Console.WriteLine("Encrypt Key :{0}", txtKey); txtIV = "Kl7ZgtM1dvQ="; btnIVGen(); Console.WriteLine("Encrypt IV :{0}", txtIV); Console.WriteLine(); string txtEncrypted = EncryptString("1111"); Console.WriteLine("Encrypt String : {0}", txtEncrypted); string txtOriginal = DecryptString(txtEncrypted); Console.WriteLine("Decrypt String : {0}", txtOriginal); Console.ReadLine(); } private static SymmetricAlgorithm mCSP; private static string txtKey; private static string txtIV; private static void btnKeyGen() { mCSP = SetEnc(); byte[] byt2 = Convert.FromBase64String(txtKey); mCSP.Key = byt2; } private static void btnIVGen() { byte[] byt2 = Convert.FromBase64String(txtIV); mCSP.IV = byt2; } private static string EncryptString(string Value) { ICryptoTransform ct; MemoryStream ms; CryptoStream cs; byte[] byt; ct = mCSP.CreateEncryptor(mCSP.Key, mCSP.IV); byt = Encoding.UTF8.GetBytes(Value); ms = new MemoryStream(); cs = new CryptoStream(ms, ct, CryptoStreamMode.Write); cs.Write(byt, 0, byt.Length); cs.FlushFinalBlock(); cs.Close(); return Convert.ToBase64String(ms.ToArray()); } private static string DecryptString(string Value) { ICryptoTransform ct; MemoryStream ms; CryptoStream cs; byte[] byt; ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV); byt = Convert.FromBase64String(Value); ms = new MemoryStream(); = the CryptoStream new new CS (MS, CT, CryptoStreamMode.Write); cs.Write (BYT, 0, byt.Length); cs.FlushFinalBlock(); cs.Close(); return Encoding.UTF8.GetString (ms.ToArray ()); } Private static SetEnc the SymmetricAlgorithm () { return the DESCryptoServiceProvider new new (); } } // output: // ----------------------------------- / / Encrypt String ... // Encrypt key: tkGGRmBErvc = // Encrypt IV: Kl7ZgtM1dvQ = // Encrypt String: 0Z5oJxsrU5Q = // Decrypt String: 1111 K1, K2, K3 determines the security of the algorithm, if three key different from each other, essentially equivalent to encrypt 168-bit key with a length. Over the years, it is in dealing with a brute force attack is relatively safe. If the data security requirements are not so high, K1 can be equal to K3. In this case, the effective key length of 112 bits. Signature: do you want to do, do not do as good as dubious.
MD5 encrypted specific flow
1. origin MD5 stands for message-digest algorithm 5 (Information - digest algorithm, inc by mit laboratory for computer science and rsa data security ronald l rivest developed in the early 1990s, the md2, md3 and md4 evolved. .http: //www.ietf.org/rfc/rfc1321.txt, is one of the most authoritative document, rivest presented by ronald l in August 1992 to IEFT.. 2. use role MD5 is information on some ( message) to generate summary information (message-digest), the digest of the unique information and to be used as a digital signature. for validation file (whether there is data missing or damaged), the encrypted password for the user, in Kazakhstan Greek function computes a hash value. 3. characteristics of the input byte string of arbitrary length, to generate a 128-bit integer. irreversible due to some features, better security in cryptographic applications. and, MD5 algorithm algorithm the use without having to pay any licensing fees. 4. illustrates the uniqueness and irreversibility are not absolute, theoretical analysis is a relationship of many to one, but the probability of the same digest information generated two different Small Irreversible means from output to input the desired reverse thrust operation and computation time is too large, a method using Qiongsou dictionary and too much storage space. The algorithm described algorithm input is a sequence of bytes, each word Day is the eight bit. execution of the algorithm consists of the following steps: a first step, fill bits: the MD5 algorithm employs two complementary input data bits, so that the data length (in byte units) the results of the remainder of the 64 56. That data is extended to the LEN = K * 64 + 56 bytes, K is an integer. fill bit method: make a 1, then 0 up to meet the above requirements corresponds to a complement of 0x80 bytes, supplemented. a value of 0 bytes. this step in the total number of bytes to add 0 to 63. The second step, an additional data length: represents the original length of a 64-bit integer data (in bit units), this number by 8 bytes front low, high in the order of the append patch site behind the data. In this case, the total length of the data to be filled: LEN = K * = 64. 8 + 56 is + (. 1 + K) * 64 Bytes. Note that the 64-bit integer ※ length original length after the input data instead of stuffing bytes, here I stumbled. The third step, MD5 initialization parameters: four 32-bit integer variables (A, B, C , D) used to calculate the message digest, each variable is initialized to the following values expressed in hexadecimal number, in front of the low-order byte. A Word: 23 is 01 45 67 Word B: 89 CD EF ab & Word C: Fe 98 BA DC Word D: 76 32 10 54 is ※ note in front of the low byte refers to a platform on the Little Endian bytes of memory arrangement , and writing in the program, should be rewritten: a = 0x67452301 B 0xefcdab89 = C = 0x98badcfe D = 0x10325476 fourth step, the definition of the four basic bitwise operations MD5 function: G (X-, the Y, the Z) = (X-and the Z) or (the Y and Not (the Z)) H (X-, the Y, the Z) the Z = X-XOR XOR the Y X-, the Y, the Z is a 32-bit integer. F. (X-, the Y, the Z) = (X-and the Y) or (Not (X-) and the Z) I (X, Y, Z) = Y xor (X or not (Z)) re-define four four separate functions for transformation. Mj is provided a message indicating that the j th packet (from 0 to 15), <<< s represents an s-bit circular left shift, as the four operations: the FF (A, B, C, D, Mj, s, Ti) represents A = B + ((A + (F. (B, C, D) + Mj of + Ti) <<< S) GG (A, B, C, D, Mj of, S, Ti) represents a = b + ((a + (G (B, C, D) + Mj of + Ti) <<< S) HH (A, B, C, D, Mj of, S, Ti) represents a = b + ((a + (H (b, c, d) + Ti + MJ) <<< S) II (A, B, C, D, MJ, S, Ti) represents a = b + ((a + (I (b, c, d) + Mj + ti) <<< s ) a fifth step, the input data for the transform processed data, N is the total number of bytes, 64 bytes for a group, for each cycle, each cycle four operation to transform 64 16 with an array of integer-byte 32-bit M [0 ... 15] denotes while the array T [1 ... 64] denotes a set of constants, T [i] is 4294967296 * abs (sin (i) ) of 32-bit integer part, I is in radians, from the value I 1 to 64. the process is as follows: / * set the main loop variables * / the For I = 0 to N / 16-1 do / * every cycle, the original data stored in an array of X 16 elements. For J = 0 to 15 do end / end of the cycle of J, / */ * the Save A AS AA, B AS BB, C AS the CC, and D AS DD. * / AA = A BB = B the CC = C DD = D / * Round 1 * / / * in [abcd ksi] represented as follows A = B + ((A + F. (B, C, D) X-+ [K] T + [I]) <<< S). * / / * the Do 16 The following operations . * / [ABCD 0. 7. 1] [DABC. 1 12 is 2] [CDAB, 2. 17. 3] [BCDA. 3 22 is. 4] [ABCD. 4. 7. 5] [DABC. 5 12 is. 6] [CDAB,. 6. 17. 7] [BCDA. 7 22 is. 8 ] [ABCD. 8. 7. 9] [DABC. 9 12 is 10] [CDAB, 10. 17. 11] [BCDA. 11 22 is 12 is] [ABCD 12 is. 7 13 is] [DABC 13 is 12 is 14] [CDAB, 14. 17 15] [BCDA 15 22 is 16] / * Round 2 * * / in [abcd ksi] expressed as follows A = B + ((A + G (B, C, D) X-+ [K] T + [I]) <<< S). * / / * The Do 16 The following Operations . * / [ABCD. 1. 5. 17] [DABC. 6. 9 18 is] [CDAB,. 11 14. 19] [BCDA 0 20 is 20 is] [ABCD. 5. 5 21 is] [DABC 10. 9 22 is] [CDAB, 15 14 23 is] [BCDA. 4 20 is 24 ] [ABCD. 9. 5 25] [DABC 14. 9 26 is] [CDAB,. 3 14 27] [BCDA. 8 20 is 28] [ABCD 13 is. 5 29] [DABC 2. 9 30] [CDAB,. 7 14 31 is] [BCDA 12 is 20 is 32] / * Round 3 * / / * to [abcd ksi] represented as follows A = B + ((A + H (B, C, D) X-+ [K] T + [I]) <<< S). * / / * the Do 16 The following Operations. * / [ABCD 33 is. 4. 5] [DABC 34 is. 8. 11] [CDAB, 16. 11 35] [BCDA 14 23 is 36] [ABCD. 1. 4 37 [] [DABC. 4. 11 38 is] [CDAB,. 7 16 39] [BCDA 10 23 is 40] [ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44] [ABCD. 9. 4 45] [DABC 12 is. 11 46 is] [CDAB, 15 16 47] [BCDA 2 23 is 48] / * Round 4 * / / * to [abcd ksi] expressed as follows a = b + ((a + I (B, C, D) X-+ [K] T + [I]) <<< S). * / / * the Do 16 The following Operations. * / [ABCD 0. 6 49] [DABC. 7 10 50] [CDAB, 14 15 51 is] [BCDA. 5 21 is 52 is] [ABCD 12 is. 6 53 is] [DABC. 3 10 54 is] [CDAB, 10 15 55] [BCDA. 1 21 is 56 is] [ABCD. 8. 6 57 is] [DABC 15 10 58] [CDAB,. 6 15 59] [BCDA 13 is 21 is 60] [ABCD. 4. 6 61 is] [DABC. 11 10 62 is] [CDAB, 2 15 63 is] [BCDA. 9 21 is 64] / * then the following steps * / A = A + AA B = B + BB the CC = C + C D = D + DD the Next I / * end of the cycle of the I * / The sixth step, the output. A, B, C, D stored in a row of 16 bytes, 128. Hexadecimal sequentially output this 16 bytes. Finally, the algorithm used programming language, you can enter the following information on the program as a simple test to see if there was anything wrong program. The MD5 ( "") = d41d8cd98f00b204e9800998ecf8427e the MD5 ( "A") = 0cc175b9c0f1b6a831c399e269772661 the MD5 ( "ABC") = 900150983cd24fb0d6963f7d28e17f72 the MD5 ( "Message Digest") = f96b697d7cb7938d525a2f31aaf161d0 the MD5 ( "ABCDEFGHIJKLMNOPQRSTUVWXYZ") = c3fcd3d76192e4007dfb496cca67e13b the MD5 ( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f the MD5 ( "12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a MD5 algorithm of C # program MD5 algorithm is rather special, the most suitable use assembly language to write, a lot of high-level language for the incompetent and weak or very low efficiency. For example, I started trying to write in Python and Euphoria, not easy to find. In contrast, C # C as the home of a new cluster .net language, function more comprehensive. She spent the last night of work with C # the first to achieve the MD5. Mainly due to less attention to some of the details of the algorithm, the resulting output is always wrong, debugging for a long time. @ Source file: md5.cs // the MD5 Alogrithm // Rufi 2004.6.20 http://rufi.yculblog.com/ by the using the System; the using the System.Collections; the using the System.IO; public class the MD5 { // static State Variables Private A static UInt32; Private static UInt32 B; Private static UInt32 C; Private static UInt32 D; // Number of bits to Rotate in tranforming Private S11 = const int. 7; Private const int = 12 is S12; Private S13 = const int. 17 ; private const int S14 = 22; private const int S21 = 5; private const int S22 = 9; private const int S23 = 14; private const int S24 = 20; private const int S31 = 4; private const int S32 = 11; private const int S33 = 16; private const int S34 = 23; private const int S41 = 6; private const int S42 = 10; private const int S43 = 15; private const int S44 = 21; /* F, G, H and I are basic MD5 functions. * 四个非线性函数: * * F(X,Y,Z) =(X&Y)|((~X)&Z) * G(X,Y,Z) =(X&Z)|(Y&(~Z)) * H(X,Y,Z) =X^Y^Z * I(X,Y,Z)=Y^(X|(~Z)) * * （&与，|或，~非，^异或） */ private static UInt32 F(UInt32 x, UInt32 y, UInt32 z) { return (x & y) | ((~x) & z); } private static UInt32 G(UInt32 x, UInt32 y, UInt32 z) { return (x & z) | (y & (~z)); } private static UInt32 H(UInt32 x, UInt32 y, UInt32 z) { return x ^ y ^ z; } private static UInt32 I(UInt32 x, UInt32 y, UInt32 z) { return y ^ (x | (~z)); } /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. * Rotation is separate from addition to prevent recomputation. */ private static void FF(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti) { a = a + F(b, c, d) + mj + ti; a = a << s | a >> (32 - s); a += b; } private static void GG(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti) { a = a + G(b, c, d) + mj + ti; a = a << s | a >> (32 - s); a += b; } private static void HH(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti) { a = a + H(b, c, d) + mj + ti; a = a << s | a >> (32 - s); a += b; } private static void II(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti) { a = a + I(b, c, d) + mj + ti; a = a << s | a >> (32 - s); a += b; } private static void MD5_Init() { A = 0x67452301; //in memory, this is 0x01234567 B = 0xefcdab89; //in memory, this is 0x89abcdef C = 0x98badcfe; //in memory, this is 0xfedcba98 D = 0x10325476; //in memory, this is 0x76543210 } private static UInt32[] MD5_Append(byte[] input) { int zeros = 0; int ones = 1; int size = 0; int n = input.Length; int m = n % 64; if (m < 56) { zeros = 55 - m; size = n - m + 64; } else if (m == 56) { zeros = 0; ones = 0; size = n + 8; } else { zeros = 63 - m + 56; size = n + 64 - m + 64; } ArrayList bs = new ArrayList(input); if (ones == 1) { bs.Add((byte)0x80); // 0x80 = $10000000 } for (int i = 0; i < zeros; i++) { bs.Add((byte)0); } UInt64 N = (UInt64)n * 8; byte h1 = (byte)(N & 0xFF); byte h2 = (byte)((N >> 8) & 0xFF); byte h3 = (byte)((N >> 16) & 0xFF); byte h4 = (byte)((N >> 24) & 0xFF); byte h5 = (byte)((N >> 32) & 0xFF); byte h6 = (byte)((N >> 40) & 0xFF); byte h7 = (byte)((N >> 48) & 0xFF); byte h8 = (byte)(N >> 56); bs.Add(h1); bs.Add(h2); bs.Add(h3); bs.Add(h4); bs.Add(h5); bs.Add(h6); bs.Add(h7); bs.Add(h8); byte[] ts = (byte[])bs.ToArray(typeof(byte)); /* Decodes input (byte[]) into output (UInt32[]). Assumes len is * a multiple of 4. */ UInt32[] output = new UInt32[size / 4]; for (Int64 i = 0, j = 0; i < size; j++, i += 4) { output[j] = (UInt32)(ts[i] | ts[i + 1] << 8 | ts[i + 2] << 16 | ts[i + 3] << 24); } return output; } private static UInt32[] MD5_Trasform(UInt32[] x) { UInt32 a, b, c, d; for (int k = 0; k < x.Length; k += 16) { a = A; b = B; c = C; d = D; /* Round 1 */ FF(ref a, b, c, d, x[k + 0], S11, 0xd76aa478); /* 1 */ FF(ref d, a, b, c, x[k + 1], S12, 0xe8c7b756); /* 2 */ FF(ref c, d, a, b, x[k + 2], S13, 0x242070db); /* 3 */ FF(ref b, c, d, a, x[k + 3], S14, 0xc1bdceee); /* 4 */ FF(ref a, b, c, d, x[k + 4], S11, 0xf57c0faf); /* 5 */ FF(ref d, a, b, c, x[k + 5], S12, 0x4787c62a); /* 6 */ FF(ref c, d, a, b, x[k + 6], S13, 0xa8304613); /* 7 */ FF(ref b, c, d, a, x[k + 7], S14, 0xfd469501); /* 8 */ FF(ref a, b, c, d, x[k + 8], S11, 0x698098d8); /* 9 */ FF(ref d, a, b, c, x[k + 9], S12, 0x8b44f7af); /* 10 */ FF(ref c, d, a, b, x[k + 10], S13, 0xffff5bb1); /* 11 */ FF(ref b, c, d, a, x[k + 11], S14, 0x895cd7be); /* 12 */ FF(ref a, b, c, d, x[k + 12], S11, 0x6b901122); /* 13 */ FF(ref d, a, b, c, x[k + 13], S12, 0xfd987193); /* 14 */ FF(ref c, d, a, b, x[k + 14], S13, 0xa679438e); /* 15 */ FF(ref b, c, d, a, x[k + 15], S14, 0x49b40821); /* 16 */ /* Round 2 */ GG(ref a, b, c, d, x[k + 1], S21, 0xf61e2562); /* 17 */ GG(ref d, a, b, c, x[k + 6], S22, 0xc040b340); /* 18 */ GG(ref c, d, a, b, x[k + 11], S23, 0x265e5a51); /* 19 */ GG(ref b, c, d, a, x[k + 0], S24, 0xe9b6c7aa); /* 20 */ GG(ref a, b, c, d, x[k + 5], S21, 0xd62f105d); /* 21 */ GG(ref d, a, b, c, x[k + 10], S22, 0x2441453); /* 22 */ GG(ref c, d, a, b, x[k + 15], S23, 0xd8a1e681); /* 23 */ GG(ref b, c, d, a, x[k + 4], S24, 0xe7d3fbc8); /* 24 */ GG(ref a, b, c, d, x[k + 9], S21, 0x21e1cde6); /* 25 */ GG(ref d, a, b, c, x[k + 14], S22, 0xc33707d6); /* 26 */ GG(ref c, d, a, b, x[k + 3], S23, 0xf4d50d87); /* 27 */ GG(ref b, c, d, a, x[k + 8], S24, 0x455a14ed); /* 28 */ GG(ref a, b, c, d, x[k + 13], S21, 0xa9e3e905); /* 29 */ GG(ref d, a, b, c, x[k + 2], S22, 0xfcefa3f8); /* 30 */ GG(ref c, d, a, b, x[k + 7], S23, 0x676f02d9); /* 31 */ GG(ref b, c, d, a, x[k + 12], S24, 0x8d2a4c8a); /* 32 */ /* Round 3 */ HH(ref a, b, c, d, x[k + 5], S31, 0xfffa3942); /* 33 */ HH(ref d, a, b, c, x[k + 8], S32, 0x8771f681); /* 34 */ HH(ref c, d, a, b, x[k + 11], S33, 0x6d9d6122); /* 35 */ HH(ref b, c, d, a, x[k + 14], S34, 0xfde5380c); /* 36 */ HH(ref a, b, c, d, x[k + 1], S31, 0xa4beea44); /* 37 */ HH(ref d, a, b, c, x[k + 4], S32, 0x4bdecfa9); /* 38 */ HH(ref c, d, a, b, x[k + 7], S33, 0xf6bb4b60); /* 39 */ HH(ref b, c, d, a, x[k + 10], S34, 0xbebfbc70); /* 40 */ HH(ref a, b, c, d, x[k + 13], S31, 0x289b7ec6); /* 41 */ HH(ref d, a, b, c, x[k + 0], S32, 0xeaa127fa); /* 42 */ HH(ref c, d, a, b, x[k + 3], S33, 0xd4ef3085); /* 43 */ HH(ref b, c, d, a, x[k + 6], S34, 0x4881d05); /* 44 */ HH(ref a, b, c, d, x[k + 9], S31, 0xd9d4d039); /* 45 */ HH(ref d, a, b, c, x[k + 12], S32, 0xe6db99e5); /* 46 */ HH(ref c, d, a, b, x[k + 15], S33, 0x1fa27cf8); /* 47 */ HH(ref b, c, d, a, x[k + 2], S34, 0xc4ac5665); /* 48 */ /* Round 4 */ II(ref a, b, c, d, x[k + 0], S41, 0xf4292244); /* 49 */ II(ref d, a, b, c, x[k + 7], S42, 0x432aff97); /* 50 */ II(ref c, d, a, b, x[k + 14], S43, 0xab9423a7); /* 51 */ II(ref b, c, d, a, x[k + 5], S44, 0xfc93a039); /* 52 */ II(ref a, b, c, d, x[k + 12], S41, 0x655b59c3); /* 53 */ II(ref d, a, b, c, x[k + 3], S42, 0x8f0ccc92); /* 54 */ II(ref c, d, a, b, x[k + 10], S43, 0xffeff47d); /* 55 */ II(ref b, c, d, a, x[k + 1], S44, 0x85845dd1); /* 56 */ II(ref a, b, c, d, x[k + 8], S41, 0x6fa87e4f); /* 57 */ II(ref d, a, b, c, x[k + 15], S42, 0xfe2ce6e0); /* 58 */ II(ref c, d, a, b, x[k + 6], S43, 0xa3014314); /* 59 */ II(ref b, c, d, a, x[k + 13], S44, 0x4e0811a1); /* 60 */ II(ref a, b, c, d, x[k + 4], S41, 0xf7537e82); /* 61 */ II(ref d, a, b, c, x[k + 11], S42, 0xbd3af235); /* 62 */ II(ref c, d, a, b, x[k + 2], S43, 0x2ad7d2bb); /* 63 */ II(ref b, c, d, a, x[k + 9], S44, 0xeb86d391); /* 64 */ A += a; B += b; C += c; D += d; } return new UInt32[] { A, B, C, D }; } public static byte[] MD5Array(byte[] input) { MD5_Init(); UInt32[] block = MD5_Append(input); UInt32[] bits = MD5_Trasform(block); /* Encodes bits (UInt32[]) into output (byte[]). Assumes len is * a multiple of 4. */ byte[] output = new byte[bits.Length * 4]; for (int i = 0, j = 0; i < bits.Length; i++, j += 4) { output[j] = (byte)(bits[i] & 0xff); output[j + 1] = (byte)((bits[i] >> 8) & 0xff); output[j + 2] = (byte)((bits[i] >> 16) & 0xff); output[j + 3] = (byte)((bits[i] >> 24) & 0xff); } return output; } public static string ArrayToHexString(byte[] array, bool uppercase) { string hexString = ""; string format = "x2"; if (uppercase) { format = "X2"; } foreach (byte b in array) { hexString += b.ToString(format); } return hexString; } public static string MDString(string message) { char[] c = message.ToCharArray(); byte[] b = new byte[c.Length]; for (int i = 0; i < c.Length; i++) { b[i] = (byte)c[i]; } byte[] digest = MD5Array(b); return ArrayToHexString(digest, false); } public static string MDFile(string fileName) { FileStream fs = File.Open(fileName, FileMode.Open, FileAccess.Read); byte[] array = new byte[fs.Length]; fs.Read(array, 0, (int)fs.Length); byte[] digest = MD5Array(array); fs.Close(); return ArrayToHexString(digest, false); } public static string Test(string message) { return "rnMD5 (" + message + ") = " + MD5.MDString(message); } static void Main(string[] args) { Console.WriteLine(Test("")); Console.WriteLine(); Console.WriteLine(Test("a")); Console.WriteLine(); Console.WriteLine(Test("abc")); Console.WriteLine(); Console.WriteLine(Test("message digest")); Console.WriteLine(); Console.WriteLine(Test("abcdefghijklmnopqrstuvwxyz")); Console.WriteLine(); Console.WriteLine (the Test ( "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")); Console.WriteLine(); Console.WriteLine (the Test ( "12345678901234567890123456789012345678901234567890123456789012345678901234567890")); Console.ReadLine (); } } Signature: do you want to do, do not do as good as dubious.