?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[LoongArch64] Part-5:add loongarch support in some files for LoongArch64. (#21769)
[mono-project.git] / mcs / class / corlib / System.Security.Cryptography / MD5CryptoServiceProvider.cs
blob80c8cb0159b081ada83af9f915e57976bd56790b
1 //
2 // System.Security.Cryptography.MD5CryptoServiceProvider.cs
3 //
4 // Authors:
5 // Matthew S. Ford (Matthew.S.Ford@Rose-Hulman.Edu)
6 // Sebastien Pouliot (sebastien@ximian.com)
7 //
8 // Copyright 2001 by Matthew S. Ford.
9 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 using System.Runtime.InteropServices;
32
33 namespace System.Security.Cryptography {
34
35 [ComVisible (true)]
36 public sealed class MD5CryptoServiceProvider : MD5 {
37 private const int BLOCK_SIZE_BYTES = 64;
38 private uint[] _H;
39 private uint[] buff;
40 private ulong count;
41 private byte[] _ProcessingBuffer; // Used to start data when passed less than a block worth.
42 private int _ProcessingBufferCount; // Counts how much data we have stored that still needs processed.
43
44 public MD5CryptoServiceProvider ()
45 {
46 _H = new uint[4];
47 buff = new uint[16];
48 _ProcessingBuffer = new byte [BLOCK_SIZE_BYTES];
49
50 Initialize();
51 }
52
53 ~MD5CryptoServiceProvider ()
54 {
55 Dispose (false);
56 }
57
58 protected override void Dispose (bool disposing)
59 {
60 if (_ProcessingBuffer != null) {
61 Array.Clear (_ProcessingBuffer, 0, _ProcessingBuffer.Length);
62 }
63 if (_H != null) {
64 Array.Clear (_H, 0, _H.Length);
65 }
66 if (buff != null) {
67 Array.Clear (buff, 0, buff.Length);
68 }
69
70 base.Dispose (disposing);
71 }
72
73 protected override void HashCore (byte[] rgb, int ibStart, int cbSize)
74 {
75 int i;
76
77 if (_ProcessingBufferCount != 0) {
78 if (cbSize < (BLOCK_SIZE_BYTES - _ProcessingBufferCount)) {
79 System.Buffer.BlockCopy (rgb, ibStart, _ProcessingBuffer, _ProcessingBufferCount, cbSize);
80 _ProcessingBufferCount += cbSize;
81 return;
82 }
83 else {
84 i = (BLOCK_SIZE_BYTES - _ProcessingBufferCount);
85 System.Buffer.BlockCopy (rgb, ibStart, _ProcessingBuffer, _ProcessingBufferCount, i);
86 ProcessBlock (_ProcessingBuffer, 0);
87 _ProcessingBufferCount = 0;
88 ibStart += i;
89 cbSize -= i;
90 }
91 }
92
93 for (i = 0; i < cbSize - cbSize % BLOCK_SIZE_BYTES; i += BLOCK_SIZE_BYTES) {
94 ProcessBlock (rgb, ibStart + i);
95 }
96
97 if (cbSize % BLOCK_SIZE_BYTES != 0) {
98 System.Buffer.BlockCopy (rgb, cbSize - cbSize % BLOCK_SIZE_BYTES + ibStart, _ProcessingBuffer, 0, cbSize % BLOCK_SIZE_BYTES);
99 _ProcessingBufferCount = cbSize % BLOCK_SIZE_BYTES;
100 }
101 }
102
103 protected override byte[] HashFinal ()
104 {
105 byte[] hash = new byte[16];
106 int i, j;
107
108 ProcessFinalBlock (_ProcessingBuffer, 0, _ProcessingBufferCount);
109
110 for (i=0; i<4; i++) {
111 for (j=0; j<4; j++) {
112 hash[i*4+j] = (byte)(_H[i] >> j*8);
113 }
114 }
115
116 return hash;
117 }
118
119 public override void Initialize ()
120 {
121 count = 0;
122 _ProcessingBufferCount = 0;
123
124 _H[0] = 0x67452301;
125 _H[1] = 0xefcdab89;
126 _H[2] = 0x98badcfe;
127 _H[3] = 0x10325476;
128 }
129
130 private void ProcessBlock (byte[] inputBuffer, int inputOffset)
131 {
132 uint a, b, c, d;
133 int i;
134
135 count += BLOCK_SIZE_BYTES;
136
137 for (i=0; i<16; i++) {
138 buff[i] = (uint)(inputBuffer[inputOffset+4*i])
139 | (((uint)(inputBuffer[inputOffset+4*i+1])) << 8)
140 | (((uint)(inputBuffer[inputOffset+4*i+2])) << 16)
141 | (((uint)(inputBuffer[inputOffset+4*i+3])) << 24);
142 }
143
144 a = _H[0];
145 b = _H[1];
146 c = _H[2];
147 d = _H[3];
148
149 // This function was unrolled because it seems to be doubling our performance with current compiler/VM.
150 // Possibly roll up if this changes.
151
152 // ---- Round 1 --------
153
154 a += (((c ^ d) & b) ^ d) + (uint) K [0] + buff [0];
155 a = (a << 7) | (a >> 25);
156 a += b;
157
158 d += (((b ^ c) & a) ^ c) + (uint) K [1] + buff [1];
159 d = (d << 12) | (d >> 20);
160 d += a;
161
162 c += (((a ^ b) & d) ^ b) + (uint) K [2] + buff [2];
163 c = (c << 17) | (c >> 15);
164 c += d;
165
166 b += (((d ^ a) & c) ^ a) + (uint) K [3] + buff [3];
167 b = (b << 22) | (b >> 10);
168 b += c;
169
170 a += (((c ^ d) & b) ^ d) + (uint) K [4] + buff [4];
171 a = (a << 7) | (a >> 25);
172 a += b;
173
174 d += (((b ^ c) & a) ^ c) + (uint) K [5] + buff [5];
175 d = (d << 12) | (d >> 20);
176 d += a;
177
178 c += (((a ^ b) & d) ^ b) + (uint) K [6] + buff [6];
179 c = (c << 17) | (c >> 15);
180 c += d;
181
182 b += (((d ^ a) & c) ^ a) + (uint) K [7] + buff [7];
183 b = (b << 22) | (b >> 10);
184 b += c;
185
186 a += (((c ^ d) & b) ^ d) + (uint) K [8] + buff [8];
187 a = (a << 7) | (a >> 25);
188 a += b;
189
190 d += (((b ^ c) & a) ^ c) + (uint) K [9] + buff [9];
191 d = (d << 12) | (d >> 20);
192 d += a;
193
194 c += (((a ^ b) & d) ^ b) + (uint) K [10] + buff [10];
195 c = (c << 17) | (c >> 15);
196 c += d;
197
198 b += (((d ^ a) & c) ^ a) + (uint) K [11] + buff [11];
199 b = (b << 22) | (b >> 10);
200 b += c;
201
202 a += (((c ^ d) & b) ^ d) + (uint) K [12] + buff [12];
203 a = (a << 7) | (a >> 25);
204 a += b;
205
206 d += (((b ^ c) & a) ^ c) + (uint) K [13] + buff [13];
207 d = (d << 12) | (d >> 20);
208 d += a;
209
210 c += (((a ^ b) & d) ^ b) + (uint) K [14] + buff [14];
211 c = (c << 17) | (c >> 15);
212 c += d;
213
214 b += (((d ^ a) & c) ^ a) + (uint) K [15] + buff [15];
215 b = (b << 22) | (b >> 10);
216 b += c;
217
218
219 // ---- Round 2 --------
220
221 a += (((b ^ c) & d) ^ c) + (uint) K [16] + buff [1];
222 a = (a << 5) | (a >> 27);
223 a += b;
224
225 d += (((a ^ b) & c) ^ b) + (uint) K [17] + buff [6];
226 d = (d << 9) | (d >> 23);
227 d += a;
228
229 c += (((d ^ a) & b) ^ a) + (uint) K [18] + buff [11];
230 c = (c << 14) | (c >> 18);
231 c += d;
232
233 b += (((c ^ d) & a) ^ d) + (uint) K [19] + buff [0];
234 b = (b << 20) | (b >> 12);
235 b += c;
236
237 a += (((b ^ c) & d) ^ c) + (uint) K [20] + buff [5];
238 a = (a << 5) | (a >> 27);
239 a += b;
240
241 d += (((a ^ b) & c) ^ b) + (uint) K [21] + buff [10];
242 d = (d << 9) | (d >> 23);
243 d += a;
244
245 c += (((d ^ a) & b) ^ a) + (uint) K [22] + buff [15];
246 c = (c << 14) | (c >> 18);
247 c += d;
248
249 b += (((c ^ d) & a) ^ d) + (uint) K [23] + buff [4];
250 b = (b << 20) | (b >> 12);
251 b += c;
252
253 a += (((b ^ c) & d) ^ c) + (uint) K [24] + buff [9];
254 a = (a << 5) | (a >> 27);
255 a += b;
256
257 d += (((a ^ b) & c) ^ b) + (uint) K [25] + buff [14];
258 d = (d << 9) | (d >> 23);
259 d += a;
260
261 c += (((d ^ a) & b) ^ a) + (uint) K [26] + buff [3];
262 c = (c << 14) | (c >> 18);
263 c += d;
264
265 b += (((c ^ d) & a) ^ d) + (uint) K [27] + buff [8];
266 b = (b << 20) | (b >> 12);
267 b += c;
268
269 a += (((b ^ c) & d) ^ c) + (uint) K [28] + buff [13];
270 a = (a << 5) | (a >> 27);
271 a += b;
272
273 d += (((a ^ b) & c) ^ b) + (uint) K [29] + buff [2];
274 d = (d << 9) | (d >> 23);
275 d += a;
276
277 c += (((d ^ a) & b) ^ a) + (uint) K [30] + buff [7];
278 c = (c << 14) | (c >> 18);
279 c += d;
280
281 b += (((c ^ d) & a) ^ d) + (uint) K [31] + buff [12];
282 b = (b << 20) | (b >> 12);
283 b += c;
284
285
286 // ---- Round 3 --------
287
288 a += (b ^ c ^ d) + (uint) K [32] + buff [5];
289 a = (a << 4) | (a >> 28);
290 a += b;
291
292 d += (a ^ b ^ c) + (uint) K [33] + buff [8];
293 d = (d << 11) | (d >> 21);
294 d += a;
295
296 c += (d ^ a ^ b) + (uint) K [34] + buff [11];
297 c = (c << 16) | (c >> 16);
298 c += d;
299
300 b += (c ^ d ^ a) + (uint) K [35] + buff [14];
301 b = (b << 23) | (b >> 9);
302 b += c;
303
304 a += (b ^ c ^ d) + (uint) K [36] + buff [1];
305 a = (a << 4) | (a >> 28);
306 a += b;
307
308 d += (a ^ b ^ c) + (uint) K [37] + buff [4];
309 d = (d << 11) | (d >> 21);
310 d += a;
311
312 c += (d ^ a ^ b) + (uint) K [38] + buff [7];
313 c = (c << 16) | (c >> 16);
314 c += d;
315
316 b += (c ^ d ^ a) + (uint) K [39] + buff [10];
317 b = (b << 23) | (b >> 9);
318 b += c;
319
320 a += (b ^ c ^ d) + (uint) K [40] + buff [13];
321 a = (a << 4) | (a >> 28);
322 a += b;
323
324 d += (a ^ b ^ c) + (uint) K [41] + buff [0];
325 d = (d << 11) | (d >> 21);
326 d += a;
327
328 c += (d ^ a ^ b) + (uint) K [42] + buff [3];
329 c = (c << 16) | (c >> 16);
330 c += d;
331
332 b += (c ^ d ^ a) + (uint) K [43] + buff [6];
333 b = (b << 23) | (b >> 9);
334 b += c;
335
336 a += (b ^ c ^ d) + (uint) K [44] + buff [9];
337 a = (a << 4) | (a >> 28);
338 a += b;
339
340 d += (a ^ b ^ c) + (uint) K [45] + buff [12];
341 d = (d << 11) | (d >> 21);
342 d += a;
343
344 c += (d ^ a ^ b) + (uint) K [46] + buff [15];
345 c = (c << 16) | (c >> 16);
346 c += d;
347
348 b += (c ^ d ^ a) + (uint) K [47] + buff [2];
349 b = (b << 23) | (b >> 9);
350 b += c;
351
352
353 // ---- Round 4 --------
354
355 a += (((~d) | b) ^ c) + (uint) K [48] + buff [0];
356 a = (a << 6) | (a >> 26);
357 a += b;
358
359 d += (((~c) | a) ^ b) + (uint) K [49] + buff [7];
360 d = (d << 10) | (d >> 22);
361 d += a;
362
363 c += (((~b) | d) ^ a) + (uint) K [50] + buff [14];
364 c = (c << 15) | (c >> 17);
365 c += d;
366
367 b += (((~a) | c) ^ d) + (uint) K [51] + buff [5];
368 b = (b << 21) | (b >> 11);
369 b += c;
370
371 a += (((~d) | b) ^ c) + (uint) K [52] + buff [12];
372 a = (a << 6) | (a >> 26);
373 a += b;
374
375 d += (((~c) | a) ^ b) + (uint) K [53] + buff [3];
376 d = (d << 10) | (d >> 22);
377 d += a;
378
379 c += (((~b) | d) ^ a) + (uint) K [54] + buff [10];
380 c = (c << 15) | (c >> 17);
381 c += d;
382
383 b += (((~a) | c) ^ d) + (uint) K [55] + buff [1];
384 b = (b << 21) | (b >> 11);
385 b += c;
386
387 a += (((~d) | b) ^ c) + (uint) K [56] + buff [8];
388 a = (a << 6) | (a >> 26);
389 a += b;
390
391 d += (((~c) | a) ^ b) + (uint) K [57] + buff [15];
392 d = (d << 10) | (d >> 22);
393 d += a;
394
395 c += (((~b) | d) ^ a) + (uint) K [58] + buff [6];
396 c = (c << 15) | (c >> 17);
397 c += d;
398
399 b += (((~a) | c) ^ d) + (uint) K [59] + buff [13];
400 b = (b << 21) | (b >> 11);
401 b += c;
402
403 a += (((~d) | b) ^ c) + (uint) K [60] + buff [4];
404 a = (a << 6) | (a >> 26);
405 a += b;
406
407 d += (((~c) | a) ^ b) + (uint) K [61] + buff [11];
408 d = (d << 10) | (d >> 22);
409 d += a;
410
411 c += (((~b) | d) ^ a) + (uint) K [62] + buff [2];
412 c = (c << 15) | (c >> 17);
413 c += d;
414
415 b += (((~a) | c) ^ d) + (uint) K [63] + buff [9];
416 b = (b << 21) | (b >> 11);
417 b += c;
418
419 _H [0] += a;
420 _H [1] += b;
421 _H [2] += c;
422 _H [3] += d;
423 }
424
425 private void ProcessFinalBlock (byte[] inputBuffer, int inputOffset, int inputCount)
426 {
427 ulong total = count + (ulong)inputCount;
428 int paddingSize = (int)(56 - total % BLOCK_SIZE_BYTES);
429
430 if (paddingSize < 1)
431 paddingSize += BLOCK_SIZE_BYTES;
432
433 byte[] fooBuffer = new byte [inputCount+paddingSize+8];
434
435 for (int i=0; i<inputCount; i++) {
436 fooBuffer[i] = inputBuffer[i+inputOffset];
437 }
438
439 fooBuffer[inputCount] = 0x80;
440 for (int i=inputCount+1; i<inputCount+paddingSize; i++) {
441 fooBuffer[i] = 0x00;
442 }
443
444 // I deal in bytes. The algorithm deals in bits.
445 ulong size = total << 3;
446 AddLength (size, fooBuffer, inputCount+paddingSize);
447 ProcessBlock (fooBuffer, 0);
448
449 if (inputCount+paddingSize+8 == 128) {
450 ProcessBlock(fooBuffer, 64);
451 }
452 }
453
454 internal void AddLength (ulong length, byte[] buffer, int position)
455 {
456 buffer [position++] = (byte)(length);
457 buffer [position++] = (byte)(length >> 8);
458 buffer [position++] = (byte)(length >> 16);
459 buffer [position++] = (byte)(length >> 24);
460 buffer [position++] = (byte)(length >> 32);
461 buffer [position++] = (byte)(length >> 40);
462 buffer [position++] = (byte)(length >> 48);
463 buffer [position] = (byte)(length >> 56);
464 }
465
466 private readonly static uint[] K = {
467 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
468 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
469 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
470 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
471 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
472 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
473 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
474 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
475 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
476 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
477 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
478 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
479 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
480 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
481 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
482 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
483 };
484 }
485 }
486
Mirror of the official Mono project git repository