2 // System.Security.Cryptography.SHA512Managed.cs
5 // Dan Lewis (dihlewis@yahoo.co.uk)
6 // Sebastien Pouliot (sebastien@ximian.com)
9 // Implementation translated from Bouncy Castle JCE (http://www.bouncycastle.org/)
10 // See bouncycastle.txt for license.
11 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
13 // Permission is hereby granted, free of charge, to any person obtaining
14 // a copy of this software and associated documentation files (the
15 // "Software"), to deal in the Software without restriction, including
16 // without limitation the rights to use, copy, modify, merge, publish,
17 // distribute, sublicense, and/or sell copies of the Software, and to
18 // permit persons to whom the Software is furnished to do so, subject to
19 // the following conditions:
21 // The above copyright notice and this permission notice shall be
22 // included in all copies or substantial portions of the Software.
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33 using System.Runtime.InteropServices;
35 namespace System.Security.Cryptography {
38 public class SHA512Managed : SHA512 {
43 private ulong byteCount1;
44 private ulong byteCount2;
46 private ulong H1, H2, H3, H4, H5, H6, H7, H8;
51 public SHA512Managed ()
55 Initialize (false); // limited initialization
58 private void Initialize (bool reuse)
60 // SHA-512 initial hash value
61 // The first 64 bits of the fractional parts of the square roots
62 // of the first eight prime numbers
63 H1 = 0x6a09e667f3bcc908L;
64 H2 = 0xbb67ae8584caa73bL;
65 H3 = 0x3c6ef372fe94f82bL;
66 H4 = 0xa54ff53a5f1d36f1L;
67 H5 = 0x510e527fade682d1L;
68 H6 = 0x9b05688c2b3e6c1fL;
69 H7 = 0x1f83d9abfb41bd6bL;
70 H8 = 0x5be0cd19137e2179L;
77 for (int i = 0; i < xBuf.Length; i++)
81 for (int i = 0; i != W.Length; i++)
86 public override void Initialize ()
88 Initialize (true); // reuse instance
93 protected override void HashCore (byte[] rgb, int ibStart, int cbSize)
95 // fill the current word
96 while ((xBufOff != 0) && (cbSize > 0)) {
97 update (rgb [ibStart]);
102 // process whole words.
103 while (cbSize > xBuf.Length) {
104 processWord (rgb, ibStart);
105 ibStart += xBuf.Length;
106 cbSize -= xBuf.Length;
107 byteCount1 += (ulong) xBuf.Length;
110 // load in the remainder.
112 update (rgb [ibStart]);
118 protected override byte[] HashFinal ()
122 ulong lowBitLength = byteCount1 << 3;
123 ulong hiBitLength = byteCount2;
125 // add the pad bytes.
130 processLength (lowBitLength, hiBitLength);
133 byte[] output = new byte [64];
134 unpackWord(H1, output, 0);
135 unpackWord(H2, output, 8);
136 unpackWord(H3, output, 16);
137 unpackWord(H4, output, 24);
138 unpackWord(H5, output, 32);
139 unpackWord(H6, output, 40);
140 unpackWord(H7, output, 48);
141 unpackWord(H8, output, 56);
147 private void update (byte input)
149 xBuf [xBufOff++] = input;
150 if (xBufOff == xBuf.Length) {
151 processWord(xBuf, 0);
157 private void processWord (byte[] input, int inOff)
159 W [wOff++] = ( (ulong) input [inOff] << 56)
160 | ( (ulong) input [inOff + 1] << 48)
161 | ( (ulong) input [inOff + 2] << 40)
162 | ( (ulong) input [inOff + 3] << 32)
163 | ( (ulong) input [inOff + 4] << 24)
164 | ( (ulong) input [inOff + 5] << 16)
165 | ( (ulong) input [inOff + 6] << 8)
166 | ( (ulong) input [inOff + 7]);
171 private void unpackWord (ulong word, byte[] output, int outOff)
173 output[outOff] = (byte) (word >> 56);
174 output[outOff + 1] = (byte) (word >> 48);
175 output[outOff + 2] = (byte) (word >> 40);
176 output[outOff + 3] = (byte) (word >> 32);
177 output[outOff + 4] = (byte) (word >> 24);
178 output[outOff + 5] = (byte) (word >> 16);
179 output[outOff + 6] = (byte) (word >> 8);
180 output[outOff + 7] = (byte) word;
183 // adjust the byte counts so that byteCount2 represents the
184 // upper long (less 3 bits) word of the byte count.
185 private void adjustByteCounts ()
187 if (byteCount1 > 0x1fffffffffffffffL) {
188 byteCount2 += (byteCount1 >> 61);
189 byteCount1 &= 0x1fffffffffffffffL;
193 private void processLength (ulong lowW, ulong hiW)
201 private void processBlock ()
204 // expand 16 word block into 80 word blocks.
205 for (int t = 16; t <= 79; t++)
206 W[t] = Sigma1 (W [t - 2]) + W [t - 7] + Sigma0 (W [t - 15]) + W [t - 16];
208 // set up working variables.
218 for (int t = 0; t <= 79; t++) {
219 ulong T1 = h + Sum1 (e) + Ch (e, f, g) + SHAConstants.K2 [t] + W [t];
220 ulong T2 = Sum0 (a) + Maj (a, b, c);
239 // reset the offset and clean out the word buffer.
241 for (int i = 0; i != W.Length; i++)
245 private ulong rotateRight (ulong x, int n)
247 return (x >> n) | (x << (64 - n));
250 /* SHA-512 and SHA-512 functions (as for SHA-256 but for longs) */
251 private ulong Ch (ulong x, ulong y, ulong z)
253 return ((x & y) ^ ((~x) & z));
256 private ulong Maj (ulong x, ulong y, ulong z)
258 return ((x & y) ^ (x & z) ^ (y & z));
261 private ulong Sum0 (ulong x)
263 return rotateRight (x, 28) ^ rotateRight (x, 34) ^ rotateRight (x, 39);
266 private ulong Sum1 (ulong x)
268 return rotateRight (x, 14) ^ rotateRight (x, 18) ^ rotateRight (x, 41);
271 private ulong Sigma0 (ulong x)
273 return rotateRight (x, 1) ^ rotateRight(x, 8) ^ (x >> 7);
276 private ulong Sigma1 (ulong x)
278 return rotateRight (x, 19) ^ rotateRight (x, 61) ^ (x >> 6);