source: trunk/CrypPlugins/MD5Collider/Algorithm/IHVCalculator.cs @ 1183

Last change on this file since 1183 was 1183, checked in by pretzsch, 12 years ago

+ MD5Collider: Added description
+ MD5Collider: Added new optional input allowing user to specify prefix of generated colliding data blocks
o MD5Collider: Made RandomSeed input optional

File size: 7.7 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5
6namespace Cryptool.Plugins.MD5Collider.Algorithm
7{
8    class IHVCalculator
9    {
10        private byte[] data;
11
12        public IHVCalculator(byte[] data)
13        {
14            this.data = data;
15        }
16
17        public byte[] GetIHV()
18        {
19            int offset = 0;
20
21            UInt32[] hv = new UInt32[] { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476 };
22            while (data.Length > offset)
23            {
24                UInt32[] dataBlock = toLittleEndianIntegerArray(data, offset, 16);
25                md5_compress(hv, dataBlock);
26                offset += 64;
27            }
28
29            byte[] result = new byte[16];
30            dumpLittleEndianIntegers(hv, result, 0);
31
32            return result;
33        }
34
35        void md5_compress(UInt32[] ihv, UInt32[] block)
36        {
37            UInt32 a = ihv[0];
38            UInt32 b = ihv[1];
39            UInt32 c = ihv[2];
40            UInt32 d = ihv[3];
41
42            MD5_STEP(FF, ref a, b, c, d, block[0], 0xd76aa478, 7);
43            MD5_STEP(FF, ref d, a, b, c, block[1], 0xe8c7b756, 12);
44            MD5_STEP(FF, ref c, d, a, b, block[2], 0x242070db, 17);
45            MD5_STEP(FF, ref b, c, d, a, block[3], 0xc1bdceee, 22);
46            MD5_STEP(FF, ref a, b, c, d, block[4], 0xf57c0faf, 7);
47            MD5_STEP(FF, ref d, a, b, c, block[5], 0x4787c62a, 12);
48            MD5_STEP(FF, ref c, d, a, b, block[6], 0xa8304613, 17);
49            MD5_STEP(FF, ref b, c, d, a, block[7], 0xfd469501, 22);
50            MD5_STEP(FF, ref a, b, c, d, block[8], 0x698098d8, 7);
51            MD5_STEP(FF, ref d, a, b, c, block[9], 0x8b44f7af, 12);
52            MD5_STEP(FF, ref c, d, a, b, block[10], 0xffff5bb1, 17);
53            MD5_STEP(FF, ref b, c, d, a, block[11], 0x895cd7be, 22);
54            MD5_STEP(FF, ref a, b, c, d, block[12], 0x6b901122, 7);
55            MD5_STEP(FF, ref d, a, b, c, block[13], 0xfd987193, 12);
56            MD5_STEP(FF, ref c, d, a, b, block[14], 0xa679438e, 17);
57            MD5_STEP(FF, ref b, c, d, a, block[15], 0x49b40821, 22);
58            MD5_STEP(GG, ref a, b, c, d, block[1], 0xf61e2562, 5);
59            MD5_STEP(GG, ref d, a, b, c, block[6], 0xc040b340, 9);
60            MD5_STEP(GG, ref c, d, a, b, block[11], 0x265e5a51, 14);
61            MD5_STEP(GG, ref b, c, d, a, block[0], 0xe9b6c7aa, 20);
62            MD5_STEP(GG, ref a, b, c, d, block[5], 0xd62f105d, 5);
63            MD5_STEP(GG, ref d, a, b, c, block[10], 0x02441453, 9);
64            MD5_STEP(GG, ref c, d, a, b, block[15], 0xd8a1e681, 14);
65            MD5_STEP(GG, ref b, c, d, a, block[4], 0xe7d3fbc8, 20);
66            MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
67            MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
68            MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
69            MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
70            MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
71            MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
72            MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
73            MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
74            MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
75            MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
76            MD5_STEP(HH, ref c, d, a, b, block[11], 0x6d9d6122, 16);
77            MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
78            MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
79            MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
80            MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
81            MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
82            MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
83            MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
84            MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
85            MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
86            MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
87            MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
88            MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
89            MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
90            MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
91            MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
92            MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
93            MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
94            MD5_STEP(II, ref  a, b, c, d, block[12], 0x655b59c3, 6);
95            MD5_STEP(II, ref  d, a, b, c, block[3], 0x8f0ccc92, 10);
96            MD5_STEP(II, ref  c, d, a, b, block[10], 0xffeff47d, 15);
97            MD5_STEP(II, ref  b, c, d, a, block[1], 0x85845dd1, 21);
98            MD5_STEP(II, ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
99            MD5_STEP(II, ref  d, a, b, c, block[15], 0xfe2ce6e0, 10);
100            MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
101            MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
102            MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
103            MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
104            MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
105            MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
106
107            ihv[0] += a;
108            ihv[1] += b;
109            ihv[2] += c;
110            ihv[3] += d;
111        }
112
113        delegate UInt32 RoundFunctionDelegate(UInt32 b, UInt32 c, UInt32 d);
114
115        void MD5_STEP(RoundFunctionDelegate f, ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 m, UInt32 ac, Int32 rc)
116        {
117            a += f(b, c, d) + m + ac;
118            a = (a << rc | a >> (32 - rc)) + b;
119        }
120
121        private void dumpLittleEndianIntegers(UInt32[] sourceArray, byte[] targetArray, int targetOffset)
122        {
123            for (int i = 0; i < sourceArray.Length; i++)
124                dumpLittleEndianInteger(sourceArray[i], targetArray, targetOffset + i * 4);
125        }
126
127        private void dumpLittleEndianInteger(UInt32 integerValue, byte[] targetArray, int targetOffset)
128        {
129            byte[] result = BitConverter.GetBytes(integerValue);
130            if (!BitConverter.IsLittleEndian)
131                Array.Reverse(result);
132
133            Array.Copy(result, 0, targetArray, targetOffset, 4);
134        }
135
136        private UInt32 toLittleEndianInteger(byte[] bytes, int offset)
137        {
138            byte[] bytesInProperOrder = new byte[4];
139            Array.Copy(bytes, offset, bytesInProperOrder, 0, 4);
140            if (!BitConverter.IsLittleEndian)
141                Array.Reverse(bytesInProperOrder);
142
143            return BitConverter.ToUInt32(bytesInProperOrder, 0);
144        }
145        private UInt32 toLittleEndianInteger(byte[] bytes)
146        {
147            return toLittleEndianInteger(bytes, 0);
148        }
149
150        private UInt32[] toLittleEndianIntegerArray(byte[] bytes, int offset, int integerCount)
151        {
152            UInt32[] result = new UInt32[integerCount];
153            for (int i = 0; i < result.Length; i++)
154                result[i] = toLittleEndianInteger(bytes, offset + i * 4);
155
156            return result;
157        }
158
159        UInt32 FF(UInt32 b, UInt32 c, UInt32 d)
160        { return d ^ (b & (c ^ d)); }
161
162        UInt32 GG(UInt32 b, UInt32 c, UInt32 d)
163        { return c ^ (d & (b ^ c)); }
164
165        UInt32 HH(UInt32 b, UInt32 c, UInt32 d)
166        { return b ^ c ^ d; }
167
168        UInt32 II(UInt32 b, UInt32 c, UInt32 d)
169        { return c ^ (b | ~d); }
170
171        UInt32 RL(UInt32 x, int n)
172        { return (x << n) | (x >> (32 - n)); }
173
174        UInt32 RR(UInt32 x, int n)
175        { return (x >> n) | (x << (32 - n)); }
176    }
177}
Note: See TracBrowser for help on using the repository browser.