< Summary

Information
Class: Hash.Core.Utils
Assembly: Hash.Core
File(s): /home/runner/work/HashCalculator/HashCalculator/src/Hash.Core/RIPEMD160Managed.cs
Line coverage
100%
Covered lines: 12
Uncovered lines: 0
Coverable lines: 12
Total lines: 1046
Line coverage: 100%
Branch coverage
100%
Covered branches: 4
Total branches: 4
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
DWORDFromLittleEndian(...)100%22100%
DWORDToLittleEndian(...)100%22100%

File(s)

/home/runner/work/HashCalculator/HashCalculator/src/Hash.Core/RIPEMD160Managed.cs

#LineLine coverage
 1// ==++==
 2//
 3//   Copyright (c) Microsoft Corporation.  All rights reserved.
 4//
 5// ==--==
 6// <OWNER>Microsoft</OWNER>
 7//
 8
 9// MIT License
 10// https://github.com/microsoft/referencesource/blob/51cf7850defa8a17d815b4700b67116e3fa283c2/LICENSE.txt
 11//
 12// See NOTICE.md for the full license text.
 13
 14//
 15// RIPEMD160Managed.cs
 16// https://github.com/microsoft/referencesource/blob/51cf7850defa8a17d815b4700b67116e3fa283c2/mscorlib/system/security/c
 17//
 18// RIPEMD-160 algorithm by Antoon Bosselaers, described at
 19// http://www.esat.kuleuven.ac.be/~cosicart/ps/AB-9601/.
 20//
 21
 22using System;
 23//using System.Diagnostics.Contracts;
 24using System.Security.Cryptography;
 25
 26namespace Hash.Core;
 27
 28[System.Runtime.InteropServices.ComVisible(true)]
 29public class RIPEMD160Managed : HashAlgorithm
 30{
 31    private byte[]      _buffer;
 32    private long        _count; // Number of bytes in the hashed message
 33    private uint[]      _stateMD160;
 34    private uint[]      _blockDWords;
 35
 36    public RIPEMD160Managed() {
 37        // .NET Framework 2.0 - 4.7.2 rejected all managed implementations when in FIPS mode
 38        // because the implementations are not certified. For applications which needed to
 39        // have FIPS mode enabled but also process RIPEMD160 (where there is not native Windows
 40        // crypto support), there was no good option, and the throw is no longer done.
 41        //
 42        // Since RIPEMD160 is not a FIPS-Approved algorithm anyway, this just means that an
 43        // application or library needs to determine on its own if RIPEMD160 is prohibited in context.
 44        if (CryptoConfig.AllowOnlyFipsAlgorithms/* && AppContextSwitches.UseLegacyFipsThrow*/) {
 45            throw new InvalidOperationException(
 46                "This implementation is not part of the Windows Platform FIPS validated cryptographic algorithms."
 47            );
 48        }
 49        //Contract.EndContractBlock();
 50
 51        _stateMD160 = new uint[5];
 52        _blockDWords = new uint[16];
 53        _buffer = new byte[64];
 54
 55        InitializeState();
 56    }
 57
 58    public override void Initialize() {
 59        InitializeState();
 60
 61        // Zeroize potentially sensitive information.
 62        Array.Clear(_blockDWords, 0, _blockDWords.Length);
 63        Array.Clear(_buffer, 0, _buffer.Length);
 64    }
 65
 66    protected override void HashCore(byte[] rgb, int ibStart, int cbSize) {
 67        _HashData(rgb, ibStart, cbSize);
 68    }
 69
 70    protected override byte[] HashFinal() {
 71        return _EndHash();
 72    }
 73
 74    private void InitializeState() {
 75        _count = 0;
 76
 77        // Use the same chaining values (IVs) as in SHA1,
 78        // The convention is little endian however (same as MD4)
 79        _stateMD160[0] =  0x67452301;
 80        _stateMD160[1] =  0xefcdab89;
 81        _stateMD160[2] =  0x98badcfe;
 82        _stateMD160[3] =  0x10325476;
 83        _stateMD160[4] =  0xc3d2e1f0;
 84    }
 85
 86    private void _HashData(byte[] partIn, int ibStart, int cbSize) {
 87        int bufferLen;
 88        int partInLen = cbSize;
 89        int partInBase = ibStart;
 90
 91        /* Compute length of buffer */
 92        bufferLen = (int) (_count & 0x3f);
 93
 94        /* Update number of bytes */
 95        _count += partInLen;
 96
 97        if ((bufferLen > 0) && (bufferLen + partInLen >= 64)) {
 98            Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, 64 - bufferLen);
 99            partInBase += (64 - bufferLen);
 100            partInLen -= (64 - bufferLen);
 101            MDTransform(_blockDWords, _stateMD160, _buffer);
 102            bufferLen = 0;
 103        }
 104
 105        /* Copy input to temporary buffer and hash */
 106        while (partInLen >= 64) {
 107            Buffer.BlockCopy(partIn, partInBase, _buffer, 0, 64);
 108            partInBase += 64;
 109            partInLen -= 64;
 110            MDTransform(_blockDWords, _stateMD160, _buffer);
 111        }
 112
 113        if (partInLen > 0) {
 114            Buffer.BlockCopy(partIn, partInBase, _buffer, bufferLen, partInLen);
 115        }
 116    }
 117
 118    private byte[] _EndHash() {
 119        byte[]          pad;
 120        int             padLen;
 121        long            bitCount;
 122        byte[]          hash = new byte[20];
 123
 124        // Compute padding: 80 00 00 ... 00 00 <bit count>
 125
 126        padLen = 64 - (int)(_count & 0x3f);
 127        if (padLen <= 8)
 128            padLen += 64;
 129
 130        pad = new byte[padLen];
 131        pad[0] = 0x80;
 132
 133        // Convert count to bit count
 134        bitCount = _count * 8;
 135
 136        // The convention for RIPEMD is little endian (the same as MD4)
 137        pad[padLen-1] = (byte) ((bitCount >> 56) & 0xff);
 138        pad[padLen-2] = (byte) ((bitCount >> 48) & 0xff);
 139        pad[padLen-3] = (byte) ((bitCount >> 40) & 0xff);
 140        pad[padLen-4] = (byte) ((bitCount >> 32) & 0xff);
 141        pad[padLen-5] = (byte) ((bitCount >> 24) & 0xff);
 142        pad[padLen-6] = (byte) ((bitCount >> 16) & 0xff);
 143        pad[padLen-7] = (byte) ((bitCount >> 8) & 0xff);
 144        pad[padLen-8] = (byte) ((bitCount >> 0) & 0xff);
 145
 146        /* Digest padding */
 147        _HashData(pad, 0, pad.Length);
 148
 149        /* Store digest */
 150        Utils.DWORDToLittleEndian(hash, _stateMD160, 5);
 151
 152        HashValue = hash;
 153        return hash;
 154    }
 155
 156    private static void MDTransform (uint[] blockDWords, uint[] state, byte[] block)
 157    {
 158        uint aa = state[0];
 159        uint bb = state[1];
 160        uint cc = state[2];
 161        uint dd = state[3];
 162        uint ee = state[4];
 163
 164        uint aaa = aa;
 165        uint bbb = bb;
 166        uint ccc = cc;
 167        uint ddd = dd;
 168        uint eee = ee;
 169
 170        Utils.DWORDFromLittleEndian(blockDWords, 16, block);
 171
 172        /*
 173            As we don't have macros in C# and we don't want to pay the cost of a function call
 174            (which BTW is quite important here as we would have to pass 5 args by ref in
 175            16 * 10 = 160 function calls)
 176            we'll prefer a less compact code to a less performant code
 177        */
 178
 179        // Left Round 1
 180        // FF(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[0], 11);
 181        aa += blockDWords[0] + F(bb, cc, dd);
 182        aa = (aa << 11 | aa >> (32 - 11)) + ee;
 183        cc = (cc << 10 | cc >> (32 - 10));
 184
 185        // FF(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[1], 14);
 186        ee += blockDWords[1] + F(aa, bb, cc);
 187        ee = (ee << 14 | ee >> (32 - 14)) + dd;
 188        bb = (bb << 10 | bb >> (32 - 10));
 189
 190        // FF(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[2], 15);
 191        dd += blockDWords[2] + F(ee, aa, bb);
 192        dd = (dd << 15 | dd >> (32 - 15)) + cc;
 193        aa = (aa << 10 | aa >> (32 - 10));
 194
 195        // FF(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[3], 12);
 196        cc += blockDWords[3] + F(dd, ee, aa);
 197        cc = (cc << 12 | cc >> (32 - 12)) + bb;
 198        ee = (ee << 10 | ee >> (32 - 10));
 199
 200        // FF(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[4], 5);
 201        bb += blockDWords[4] + F(cc, dd, ee);
 202        bb = (bb << 5 | bb >> (32 - 5)) + aa;
 203        dd = (dd << 10 | dd >> (32 - 10));
 204
 205        // FF(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[5], 8);
 206        aa += blockDWords[5] + F(bb, cc, dd);
 207        aa = (aa << 8 | aa >> (32 - 8)) + ee;
 208        cc = (cc << 10 | cc >> (32 - 10));
 209
 210        // FF(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[6], 7);
 211        ee += blockDWords[6] + F(aa, bb, cc);
 212        ee = (ee << 7 | ee >> (32 - 7)) + dd;
 213        bb = (bb << 10 | bb >> (32 - 10));
 214
 215        // FF(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[7], 9);
 216        dd += blockDWords[7] + F(ee, aa, bb);
 217        dd = (dd << 9 | dd >> (32 - 9)) + cc;
 218        aa = (aa << 10 | aa >> (32 - 10));
 219
 220        // FF(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[8], 11);
 221        cc += blockDWords[8] + F(dd, ee, aa);
 222        cc = (cc << 11 | cc >> (32 - 11)) + bb;
 223        ee = (ee << 10 | ee >> (32 - 10));
 224
 225        // FF(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[9], 13);
 226        bb += blockDWords[9] + F(cc, dd, ee);
 227        bb = (bb << 13 | bb >> (32 - 13)) + aa;
 228        dd = (dd << 10 | dd >> (32 - 10));
 229
 230        // FF(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[10], 14);
 231        aa += blockDWords[10] + F(bb, cc, dd);
 232        aa = (aa << 14 | aa >> (32 - 14)) + ee;
 233        cc = (cc << 10 | cc >> (32 - 10));
 234
 235        // FF(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[11], 15);
 236        ee += blockDWords[11] + F(aa, bb, cc);
 237        ee = (ee << 15 | ee >> (32 - 15)) + dd;
 238        bb = (bb << 10 | bb >> (32 - 10));
 239
 240        // FF(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[12], 6);
 241        dd += blockDWords[12] + F(ee, aa, bb);
 242        dd = (dd << 6 | dd >> (32 - 6)) + cc;
 243        aa = (aa << 10 | aa >> (32 - 10));
 244
 245        // FF(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[13], 7);
 246        cc += blockDWords[13] + F(dd, ee, aa);
 247        cc = (cc << 7 | cc >> (32 - 7)) + bb;
 248        ee = (ee << 10 | ee >> (32 - 10));
 249
 250        // FF(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[14], 9);
 251        bb += blockDWords[14] + F(cc, dd, ee);
 252        bb = (bb << 9 | bb >> (32 - 9)) + aa;
 253        dd = (dd << 10 | dd >> (32 - 10));
 254
 255        // FF(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[15], 8);
 256        aa += blockDWords[15] + F(bb, cc, dd);
 257        aa = (aa << 8 | aa >> (32 - 8)) + ee;
 258        cc = (cc << 10 | cc >> (32 - 10));
 259
 260        // Left Round 2
 261        // GG(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[7], 7);
 262        ee += G(aa, bb, cc) + blockDWords[7] + 0x5a827999;
 263        ee = (ee << 7 | ee >> (32 - 7)) + dd;
 264        bb = (bb << 10 | bb >> (32 - 10));
 265
 266        // GG(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[4], 6);
 267        dd += G(ee, aa, bb) + blockDWords[4] + 0x5a827999;
 268        dd = (dd << 6 | dd >> (32 - 6)) + cc;
 269        aa = (aa << 10 | aa >> (32 - 10));
 270
 271        // GG(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[13], 8);
 272        cc += G(dd, ee, aa) + blockDWords[13] + 0x5a827999;
 273        cc = (cc << 8 | cc >> (32 - 8)) + bb;
 274        ee = (ee << 10 | ee >> (32 - 10));
 275
 276        // GG(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[1], 13);
 277        bb += G(cc, dd, ee) + blockDWords[1] + 0x5a827999;
 278        bb = (bb << 13 | bb >> (32 - 13)) + aa;
 279        dd = (dd << 10 | dd >> (32 - 10));
 280
 281        // GG(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[10], 11);
 282        aa += G(bb, cc, dd) + blockDWords[10] + 0x5a827999;
 283        aa = (aa << 11 | aa >> (32 - 11)) + ee;
 284        cc = (cc << 10 | cc >> (32 - 10));
 285
 286        // GG(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[6], 9);
 287        ee += G(aa, bb, cc) + blockDWords[6] + 0x5a827999;
 288        ee = (ee << 9 | ee >> (32 - 9)) + dd;
 289        bb = (bb << 10 | bb >> (32 - 10));
 290
 291        // GG(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[15], 7);
 292        dd += G(ee, aa, bb) + blockDWords[15] + 0x5a827999;
 293        dd = (dd << 7 | dd >> (32 - 7)) + cc;
 294        aa = (aa << 10 | aa >> (32 - 10));
 295
 296        // GG(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[3], 15);
 297        cc += G(dd, ee, aa) + blockDWords[3] + 0x5a827999;
 298        cc = (cc << 15 | cc >> (32 - 15)) + bb;
 299        ee = (ee << 10 | ee >> (32 - 10));
 300
 301        // GG(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[12], 7);
 302        bb += G(cc, dd, ee) + blockDWords[12] + 0x5a827999;
 303        bb = (bb << 7 | bb >> (32 - 7)) + aa;
 304        dd = (dd << 10 | dd >> (32 - 10));
 305
 306        // GG(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[0], 12);
 307        aa += G(bb, cc, dd) + blockDWords[0] + 0x5a827999;
 308        aa = (aa << 12 | aa >> (32 - 12)) + ee;
 309        cc = (cc << 10 | cc >> (32 - 10));
 310
 311        // GG(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[9], 15);
 312        ee += G(aa, bb, cc) + blockDWords[9] + 0x5a827999;
 313        ee = (ee << 15 | ee >> (32 - 15)) + dd;
 314        bb = (bb << 10 | bb >> (32 - 10));
 315
 316        // GG(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[5], 9);
 317        dd += G(ee, aa, bb) + blockDWords[5] + 0x5a827999;
 318        dd = (dd << 9 | dd >> (32 - 9)) + cc;
 319        aa = (aa << 10 | aa >> (32 - 10));
 320
 321        // GG(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[2], 11);
 322        cc += G(dd, ee, aa) + blockDWords[2] + 0x5a827999;
 323        cc = (cc << 11 | cc >> (32 - 11)) + bb;
 324        ee = (ee << 10 | ee >> (32 - 10));
 325
 326        // GG(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[14], 7);
 327        bb += G(cc, dd, ee) + blockDWords[14] + 0x5a827999;
 328        bb = (bb << 7 | bb >> (32 - 7)) + aa;
 329        dd = (dd << 10 | dd >> (32 - 10));
 330
 331        // GG(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[11], 13);
 332        aa += G(bb, cc, dd) + blockDWords[11] + 0x5a827999;
 333        aa = (aa << 13 | aa >> (32 - 13)) + ee;
 334        cc = (cc << 10 | cc >> (32 - 10));
 335
 336        // GG(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[8], 12);
 337        ee += G(aa, bb, cc) + blockDWords[8] + 0x5a827999;
 338        ee = (ee << 12 | ee >> (32 - 12)) + dd;
 339        bb = (bb << 10 | bb >> (32 - 10));
 340
 341        // Left Round 3
 342        // HH(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[3], 11);
 343        dd += H(ee, aa, bb) + blockDWords[3] + 0x6ed9eba1;
 344        dd = (dd << 11 | dd >> (32 - 11)) + cc;
 345        aa = (aa << 10 | aa >> (32 - 10));
 346
 347        // HH(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[10], 13);
 348        cc += H(dd, ee, aa) + blockDWords[10] + 0x6ed9eba1;
 349        cc = (cc << 13 | cc >> (32 - 13)) + bb;
 350        ee = (ee << 10 | ee >> (32 - 10));
 351
 352        // HH(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[14], 6);
 353        bb += H(cc, dd, ee) + blockDWords[14] + 0x6ed9eba1;
 354        bb = (bb << 6 | bb >> (32 - 6)) + aa;
 355        dd = (dd << 10 | dd >> (32 - 10));
 356
 357        // HH(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[4], 7);
 358        aa += H(bb, cc, dd) + blockDWords[4] + 0x6ed9eba1;
 359        aa = (aa << 7 | aa >> (32 - 7)) + ee;
 360        cc = (cc << 10 | cc >> (32 - 10));
 361
 362        // HH(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[9], 14);
 363        ee += H(aa, bb, cc) + blockDWords[9] + 0x6ed9eba1;
 364        ee = (ee << 14 | ee >> (32 - 14)) + dd;
 365        bb = (bb << 10 | bb >> (32 - 10));
 366
 367        // HH(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[15], 9);
 368        dd += H(ee, aa, bb) + blockDWords[15] + 0x6ed9eba1;
 369        dd = (dd << 9 | dd >> (32 - 9)) + cc;
 370        aa = (aa << 10 | aa >> (32 - 10));
 371
 372        // HH(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[8], 13);
 373        cc += H(dd, ee, aa) + blockDWords[8] + 0x6ed9eba1;
 374        cc = (cc << 13 | cc >> (32 - 13)) + bb;
 375        ee = (ee << 10 | ee >> (32 - 10));
 376
 377        // HH(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[1], 15);
 378        bb += H(cc, dd, ee) + blockDWords[1] + 0x6ed9eba1;
 379        bb = (bb << 15 | bb >> (32 - 15)) + aa;
 380        dd = (dd << 10 | dd >> (32 - 10));
 381
 382        // HH(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[2], 14);
 383        aa += H(bb, cc, dd) + blockDWords[2] + 0x6ed9eba1;
 384        aa = (aa << 14 | aa >> (32 - 14)) + ee;
 385        cc = (cc << 10 | cc >> (32 - 10));
 386
 387        // HH(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[7], 8);
 388        ee += H(aa, bb, cc) + blockDWords[7] + 0x6ed9eba1;
 389        ee = (ee << 8 | ee >> (32 - 8)) + dd;
 390        bb = (bb << 10 | bb >> (32 - 10));
 391
 392        // HH(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[0], 13);
 393        dd += H(ee, aa, bb) + blockDWords[0] + 0x6ed9eba1;
 394        dd = (dd << 13 | dd >> (32 - 13)) + cc;
 395        aa = (aa << 10 | aa >> (32 - 10));
 396
 397        // HH(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[6], 6);
 398        cc += H(dd, ee, aa) + blockDWords[6] + 0x6ed9eba1;
 399        cc = (cc << 6 | cc >> (32 - 6)) + bb;
 400        ee = (ee << 10 | ee >> (32 - 10));
 401
 402        // HH(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[13], 5);
 403        bb += H(cc, dd, ee) + blockDWords[13] + 0x6ed9eba1;
 404        bb = (bb << 5 | bb >> (32 - 5)) + aa;
 405        dd = (dd << 10 | dd >> (32 - 10));
 406
 407        // HH(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[11], 12);
 408        aa += H(bb, cc, dd) + blockDWords[11] + 0x6ed9eba1;
 409        aa = (aa << 12 | aa >> (32 - 12)) + ee;
 410        cc = (cc << 10 | cc >> (32 - 10));
 411
 412        // HH(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[5], 7);
 413        ee += H(aa, bb, cc) + blockDWords[5] + 0x6ed9eba1;
 414        ee = (ee << 7 | ee >> (32 - 7)) + dd;
 415        bb = (bb << 10 | bb >> (32 - 10));
 416
 417        // HH(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[12], 5);
 418        dd += H(ee, aa, bb) + blockDWords[12] + 0x6ed9eba1;
 419        dd = (dd << 5 | dd >> (32 - 5)) + cc;
 420        aa = (aa << 10 | aa >> (32 - 10));
 421
 422        // Left Round 4
 423        // II(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[1], 11);
 424        cc += I(dd, ee, aa) + blockDWords[1] + 0x8f1bbcdc;
 425        cc = (cc << 11 | cc >> (32 - 11)) + bb;
 426        ee = (ee << 10 | ee >> (32 - 10));
 427
 428        // II(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[9], 12);
 429        bb += I(cc, dd, ee) + blockDWords[9] + 0x8f1bbcdc;
 430        bb = (bb << 12 | bb >> (32 - 12)) + aa;
 431        dd = (dd << 10 | dd >> (32 - 10));
 432
 433        // II(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[11], 14);
 434        aa += I(bb, cc, dd) + blockDWords[11] + 0x8f1bbcdc;
 435        aa = (aa << 14 | aa >> (32 - 14)) + ee;
 436        cc = (cc << 10 | cc >> (32 - 10));
 437
 438        // II(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[10], 15);
 439        ee += I(aa, bb, cc) + blockDWords[10] + 0x8f1bbcdc;
 440        ee = (ee << 15 | ee >> (32 - 15)) + dd;
 441        bb = (bb << 10 | bb >> (32 - 10));
 442
 443        // II(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[0], 14);
 444        dd += I(ee, aa, bb) + blockDWords[0] + 0x8f1bbcdc;
 445        dd = (dd << 14 | dd >> (32 - 14)) + cc;
 446        aa = (aa << 10 | aa >> (32 - 10));
 447
 448        // II(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[8], 15);
 449        cc += I(dd, ee, aa) + blockDWords[8] + 0x8f1bbcdc;
 450        cc = (cc << 15 | cc >> (32 - 15)) + bb;
 451        ee = (ee << 10 | ee >> (32 - 10));
 452
 453        // II(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[12], 9);
 454        bb += I(cc, dd, ee) + blockDWords[12] + 0x8f1bbcdc;
 455        bb = (bb << 9 | bb >> (32 - 9)) + aa;
 456        dd = (dd << 10 | dd >> (32 - 10));
 457
 458        // II(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[4], 8);
 459        aa += I(bb, cc, dd) + blockDWords[4] + 0x8f1bbcdc;
 460        aa = (aa << 8 | aa >> (32 - 8)) + ee;
 461        cc = (cc << 10 | cc >> (32 - 10));
 462
 463        // II(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[13], 9);
 464        ee += I(aa, bb, cc) + blockDWords[13] + 0x8f1bbcdc;
 465        ee = (ee << 9 | ee >> (32 - 9)) + dd;
 466        bb = (bb << 10 | bb >> (32 - 10));
 467
 468        // II(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[3], 14);
 469        dd += I(ee, aa, bb) + blockDWords[3] + 0x8f1bbcdc;
 470        dd = (dd << 14 | dd >> (32 - 14)) + cc;
 471        aa = (aa << 10 | aa >> (32 - 10));
 472
 473        // II(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[7], 5);
 474        cc += I(dd, ee, aa) + blockDWords[7] + 0x8f1bbcdc;
 475        cc = (cc << 5 | cc >> (32 - 5)) + bb;
 476        ee = (ee << 10 | ee >> (32 - 10));
 477
 478        // II(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[15], 6);
 479        bb += I(cc, dd, ee) + blockDWords[15] + 0x8f1bbcdc;
 480        bb = (bb << 6 | bb >> (32 - 6)) + aa;
 481        dd = (dd << 10 | dd >> (32 - 10));
 482
 483        // II(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[14], 8);
 484        aa += I(bb, cc, dd) + blockDWords[14] + 0x8f1bbcdc;
 485        aa = (aa << 8 | aa >> (32 - 8)) + ee;
 486        cc = (cc << 10 | cc >> (32 - 10));
 487
 488        // II(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[5], 6);
 489        ee += I(aa, bb, cc) + blockDWords[5] + 0x8f1bbcdc;
 490        ee = (ee << 6 | ee >> (32 - 6)) + dd;
 491        bb = (bb << 10 | bb >> (32 - 10));
 492
 493        // II(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[6], 5);
 494        dd += I(ee, aa, bb) + blockDWords[6] + 0x8f1bbcdc;
 495        dd = (dd << 5 | dd >> (32 - 5)) + cc;
 496        aa = (aa << 10 | aa >> (32 - 10));
 497
 498        // II(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[2], 12);
 499        cc += I(dd, ee, aa) + blockDWords[2] + 0x8f1bbcdc;
 500        cc = (cc << 12 | cc >> (32 - 12)) + bb;
 501        ee = (ee << 10 | ee >> (32 - 10));
 502
 503        // Left Round 5
 504        // JJ(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[4], 9);
 505        bb += J(cc, dd, ee) + blockDWords[4] + 0xa953fd4e;
 506        bb = (bb << 9 | bb >> (32 - 9)) + aa;
 507        dd = (dd << 10 | dd >> (32 - 10));
 508
 509        // JJ(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[0], 15);
 510        aa += J(bb, cc, dd) + blockDWords[0] + 0xa953fd4e;
 511        aa = (aa << 15 | aa >> (32 - 15)) + ee;
 512        cc = (cc << 10 | cc >> (32 - 10));
 513
 514        // JJ(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[5], 5);
 515        ee += J(aa, bb, cc) + blockDWords[5] + 0xa953fd4e;
 516        ee = (ee << 5 | ee >> (32 - 5)) + dd;
 517        bb = (bb << 10 | bb >> (32 - 10));
 518
 519        // JJ(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[9], 11);
 520        dd += J(ee, aa, bb) + blockDWords[9] + 0xa953fd4e;
 521        dd = (dd << 11 | dd >> (32 - 11)) + cc;
 522        aa = (aa << 10 | aa >> (32 - 10));
 523
 524        // JJ(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[7], 6);
 525        cc += J(dd, ee, aa) + blockDWords[7] + 0xa953fd4e;
 526        cc = (cc << 6 | cc >> (32 - 6)) + bb;
 527        ee = (ee << 10 | ee >> (32 - 10));
 528
 529        // JJ(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[12], 8);
 530        bb += J(cc, dd, ee) + blockDWords[12] + 0xa953fd4e;
 531        bb = (bb << 8 | bb >> (32 - 8)) + aa;
 532        dd = (dd << 10 | dd >> (32 - 10));
 533
 534        // JJ(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[2], 13);
 535        aa += J(bb, cc, dd) + blockDWords[2] + 0xa953fd4e;
 536        aa = (aa << 13 | aa >> (32 - 13)) + ee;
 537        cc = (cc << 10 | cc >> (32 - 10));
 538
 539        // JJ(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[10], 12);
 540        ee += J(aa, bb, cc) + blockDWords[10] + 0xa953fd4e;
 541        ee = (ee << 12 | ee >> (32 - 12)) + dd;
 542        bb = (bb << 10 | bb >> (32 - 10));
 543
 544        // JJ(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[14], 5);
 545        dd += J(ee, aa, bb) + blockDWords[14] + 0xa953fd4e;
 546        dd = (dd << 5 | dd >> (32 - 5)) + cc;
 547        aa = (aa << 10 | aa >> (32 - 10));
 548
 549        // JJ(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[1], 12);
 550        cc += J(dd, ee, aa) + blockDWords[1] + 0xa953fd4e;
 551        cc = (cc << 12 | cc >> (32 - 12)) + bb;
 552        ee = (ee << 10 | ee >> (32 - 10));
 553
 554        // JJ(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[3], 13);
 555        bb += J(cc, dd, ee) + blockDWords[3] + 0xa953fd4e;
 556        bb = (bb << 13 | bb >> (32 - 13)) + aa;
 557        dd = (dd << 10 | dd >> (32 - 10));
 558
 559        // JJ(ref aa, ref bb, ref cc, ref dd, ref ee, blockDWords[8], 14);
 560        aa += J(bb, cc, dd) + blockDWords[8] + 0xa953fd4e;
 561        aa = (aa << 14 | aa >> (32 - 14)) + ee;
 562        cc = (cc << 10 | cc >> (32 - 10));
 563
 564        // JJ(ref ee, ref aa, ref bb, ref cc, ref dd, blockDWords[11], 11);
 565        ee += J(aa, bb, cc) + blockDWords[11] + 0xa953fd4e;
 566        ee = (ee << 11 | ee >> (32 - 11)) + dd;
 567        bb = (bb << 10 | bb >> (32 - 10));
 568
 569        // JJ(ref dd, ref ee, ref aa, ref bb, ref cc, blockDWords[6], 8);
 570        dd += J(ee, aa, bb) + blockDWords[6] + 0xa953fd4e;
 571        dd = (dd << 8 | dd >> (32 - 8)) + cc;
 572        aa = (aa << 10 | aa >> (32 - 10));
 573
 574        // JJ(ref cc, ref dd, ref ee, ref aa, ref bb, blockDWords[15], 5);
 575        cc += J(dd, ee, aa) + blockDWords[15] + 0xa953fd4e;
 576        cc = (cc << 5 | cc >> (32 - 5)) + bb;
 577        ee = (ee << 10 | ee >> (32 - 10));
 578
 579        // JJ(ref bb, ref cc, ref dd, ref ee, ref aa, blockDWords[13], 6);
 580        bb += J(cc, dd, ee) + blockDWords[13] + 0xa953fd4e;
 581        bb = (bb << 6 | bb >> (32 - 6)) + aa;
 582        dd = (dd << 10 | dd >> (32 - 10));
 583
 584        // Parallel Right Round 1
 585        // JJJ(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[5], 8);
 586        aaa += J(bbb, ccc, ddd) + blockDWords[5] + 0x50a28be6;
 587        aaa = (aaa << 8 | aaa >> (32 - 8)) + eee;
 588        ccc = (ccc << 10 | ccc >> (32 - 10));
 589
 590        // JJJ(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[14], 9);
 591        eee += J(aaa, bbb, ccc) + blockDWords[14] + 0x50a28be6;
 592        eee = (eee << 9 | eee >> (32 - 9)) + ddd;
 593        bbb = (bbb << 10 | bbb >> (32 - 10));
 594
 595        // JJJ(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[7], 9);
 596        ddd += J(eee, aaa, bbb) + blockDWords[7] + 0x50a28be6;
 597        ddd = (ddd << 9 | ddd >> (32 - 9)) + ccc;
 598        aaa = (aaa << 10 | aaa >> (32 - 10));
 599
 600        // JJJ(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[0], 11);
 601        ccc += J(ddd, eee, aaa) + blockDWords[0] + 0x50a28be6;
 602        ccc = (ccc << 11 | ccc >> (32 - 11)) + bbb;
 603        eee = (eee << 10 | eee >> (32 - 10));
 604
 605        // JJJ(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[9], 13);
 606        bbb += J(ccc, ddd, eee) + blockDWords[9] + 0x50a28be6;
 607        bbb = (bbb << 13 | bbb >> (32 - 13)) + aaa;
 608        ddd = (ddd << 10 | ddd >> (32 - 10));
 609
 610        // JJJ(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[2], 15);
 611        aaa += J(bbb, ccc, ddd) + blockDWords[2] + 0x50a28be6;
 612        aaa = (aaa << 15 | aaa >> (32 - 15)) + eee;
 613        ccc = (ccc << 10 | ccc >> (32 - 10));
 614
 615        // JJJ(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[11], 15);
 616        eee += J(aaa, bbb, ccc) + blockDWords[11] + 0x50a28be6;
 617        eee = (eee << 15 | eee >> (32 - 15)) + ddd;
 618        bbb = (bbb << 10 | bbb >> (32 - 10));
 619
 620        // JJJ(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[4], 5);
 621        ddd += J(eee, aaa, bbb) + blockDWords[4] + 0x50a28be6;
 622        ddd = (ddd << 5 | ddd >> (32 - 5)) + ccc;
 623        aaa = (aaa << 10 | aaa >> (32 - 10));
 624
 625        // JJJ(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[13], 7);
 626        ccc += J(ddd, eee, aaa) + blockDWords[13] + 0x50a28be6;
 627        ccc = (ccc << 7 | ccc >> (32 - 7)) + bbb;
 628        eee = (eee << 10 | eee >> (32 - 10));
 629
 630        // JJJ(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[6], 7);
 631        bbb += J(ccc, ddd, eee) + blockDWords[6] + 0x50a28be6;
 632        bbb = (bbb << 7 | bbb >> (32 - 7)) + aaa;
 633        ddd = (ddd << 10 | ddd >> (32 - 10));
 634
 635        // JJJ(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[15], 8);
 636        aaa += J(bbb, ccc, ddd) + blockDWords[15] + 0x50a28be6;
 637        aaa = (aaa << 8 | aaa >> (32 - 8)) + eee;
 638        ccc = (ccc << 10 | ccc >> (32 - 10));
 639
 640        // JJJ(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[8], 11);
 641        eee += J(aaa, bbb, ccc) + blockDWords[8] + 0x50a28be6;
 642        eee = (eee << 11 | eee >> (32 - 11)) + ddd;
 643        bbb = (bbb << 10 | bbb >> (32 - 10));
 644
 645        // JJJ(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[1], 14);
 646        ddd += J(eee, aaa, bbb) + blockDWords[1] + 0x50a28be6;
 647        ddd = (ddd << 14 | ddd >> (32 - 14)) + ccc;
 648        aaa = (aaa << 10 | aaa >> (32 - 10));
 649
 650        // JJJ(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[10], 14);
 651        ccc += J(ddd, eee, aaa) + blockDWords[10] + 0x50a28be6;
 652        ccc = (ccc << 14 | ccc >> (32 - 14)) + bbb;
 653        eee = (eee << 10 | eee >> (32 - 10));
 654
 655        // JJJ(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[3], 12);
 656        bbb += J(ccc, ddd, eee) + blockDWords[3] + 0x50a28be6;
 657        bbb = (bbb << 12 | bbb >> (32 - 12)) + aaa;
 658        ddd = (ddd << 10 | ddd >> (32 - 10));
 659
 660        // JJJ(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[12], 6);
 661        aaa += J(bbb, ccc, ddd) + blockDWords[12] + 0x50a28be6;
 662        aaa = (aaa << 6 | aaa >> (32 - 6)) + eee;
 663        ccc = (ccc << 10 | ccc >> (32 - 10));
 664
 665        // Parallel Right Round 2
 666        // III(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[6], 9);
 667        eee += I(aaa, bbb, ccc) + blockDWords[6] + 0x5c4dd124;
 668        eee = (eee << 9 | eee >> (32 - 9)) + ddd;
 669        bbb = (bbb << 10 | bbb >> (32 - 10));
 670
 671        // III(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[11], 13);
 672        ddd += I(eee, aaa, bbb) + blockDWords[11] + 0x5c4dd124;
 673        ddd = (ddd << 13 | ddd >> (32 - 13)) + ccc;
 674        aaa = (aaa << 10 | aaa >> (32 - 10));
 675
 676        // III(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[3], 15);
 677        ccc += I(ddd, eee, aaa) + blockDWords[3] + 0x5c4dd124;
 678        ccc = (ccc << 15 | ccc >> (32 - 15)) + bbb;
 679        eee = (eee << 10 | eee >> (32 - 10));
 680
 681        // III(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[7], 7);
 682        bbb += I(ccc, ddd, eee) + blockDWords[7] + 0x5c4dd124;
 683        bbb = (bbb << 7 | bbb >> (32 - 7)) + aaa;
 684        ddd = (ddd << 10 | ddd >> (32 - 10));
 685
 686        // III(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[0], 12);
 687        aaa += I(bbb, ccc, ddd) + blockDWords[0] + 0x5c4dd124;
 688        aaa = (aaa << 12 | aaa >> (32 - 12)) + eee;
 689        ccc = (ccc << 10 | ccc >> (32 - 10));
 690
 691        // III(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[13], 8);
 692        eee += I(aaa, bbb, ccc) + blockDWords[13] + 0x5c4dd124;
 693        eee = (eee << 8 | eee >> (32 - 8)) + ddd;
 694        bbb = (bbb << 10 | bbb >> (32 - 10));
 695
 696        // III(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[5], 9);
 697        ddd += I(eee, aaa, bbb) + blockDWords[5] + 0x5c4dd124;
 698        ddd = (ddd << 9 | ddd >> (32 - 9)) + ccc;
 699        aaa = (aaa << 10 | aaa >> (32 - 10));
 700
 701        // III(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[10], 11);
 702        ccc += I(ddd, eee, aaa) + blockDWords[10] + 0x5c4dd124;
 703        ccc = (ccc << 11 | ccc >> (32 - 11)) + bbb;
 704        eee = (eee << 10 | eee >> (32 - 10));
 705
 706        // III(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[14], 7);
 707        bbb += I(ccc, ddd, eee) + blockDWords[14] + 0x5c4dd124;
 708        bbb = (bbb << 7 | bbb >> (32 - 7)) + aaa;
 709        ddd = (ddd << 10 | ddd >> (32 - 10));
 710
 711        // III(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[15], 7);
 712        aaa += I(bbb, ccc, ddd) + blockDWords[15] + 0x5c4dd124;
 713        aaa = (aaa << 7 | aaa >> (32 - 7)) + eee;
 714        ccc = (ccc << 10 | ccc >> (32 - 10));
 715
 716        // III(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[8], 12);
 717        eee += I(aaa, bbb, ccc) + blockDWords[8] + 0x5c4dd124;
 718        eee = (eee << 12 | eee >> (32 - 12)) + ddd;
 719        bbb = (bbb << 10 | bbb >> (32 - 10));
 720
 721        // III(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[12], 7);
 722        ddd += I(eee, aaa, bbb) + blockDWords[12] + 0x5c4dd124;
 723        ddd = (ddd << 7 | ddd >> (32 - 7)) + ccc;
 724        aaa = (aaa << 10 | aaa >> (32 - 10));
 725
 726        // III(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[4], 6);
 727        ccc += I(ddd, eee, aaa) + blockDWords[4] + 0x5c4dd124;
 728        ccc = (ccc << 6 | ccc >> (32 - 6)) + bbb;
 729        eee = (eee << 10 | eee >> (32 - 10));
 730
 731        // III(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[9], 15);
 732        bbb += I(ccc, ddd, eee) + blockDWords[9] + 0x5c4dd124;
 733        bbb = (bbb << 15 | bbb >> (32 - 15)) + aaa;
 734        ddd = (ddd << 10 | ddd >> (32 - 10));
 735
 736        // III(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[1], 13);
 737        aaa += I(bbb, ccc, ddd) + blockDWords[1] + 0x5c4dd124;
 738        aaa = (aaa << 13 | aaa >> (32 - 13)) + eee;
 739        ccc = (ccc << 10 | ccc >> (32 - 10));
 740
 741        // III(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[2], 11);
 742        eee += I(aaa, bbb, ccc) + blockDWords[2] + 0x5c4dd124;
 743        eee = (eee << 11 | eee >> (32 - 11)) + ddd;
 744        bbb = (bbb << 10 | bbb >> (32 - 10));
 745
 746        // Parallel Right Round 3
 747        // HHH(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[15], 9);
 748        ddd += H(eee, aaa, bbb) + blockDWords[15] + 0x6d703ef3;
 749        ddd = (ddd << 9 | ddd >> (32 - 9)) + ccc;
 750        aaa = (aaa << 10 | aaa >> (32 - 10));
 751
 752        // HHH(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[5], 7);
 753        ccc += H(ddd, eee, aaa) + blockDWords[5] + 0x6d703ef3;
 754        ccc = (ccc << 7 | ccc >> (32 - 7)) + bbb;
 755        eee = (eee << 10 | eee >> (32 - 10));
 756
 757        // HHH(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[1], 15);
 758        bbb += H(ccc, ddd, eee) + blockDWords[1] + 0x6d703ef3;
 759        bbb = (bbb << 15 | bbb >> (32 - 15)) + aaa;
 760        ddd = (ddd << 10 | ddd >> (32 - 10));
 761
 762        // HHH(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[3], 11);
 763        aaa += H(bbb, ccc, ddd) + blockDWords[3] + 0x6d703ef3;
 764        aaa = (aaa << 11 | aaa >> (32 - 11)) + eee;
 765        ccc = (ccc << 10 | ccc >> (32 - 10));
 766
 767        // HHH(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[7], 8);
 768        eee += H(aaa, bbb, ccc) + blockDWords[7] + 0x6d703ef3;
 769        eee = (eee << 8 | eee >> (32 - 8)) + ddd;
 770        bbb = (bbb << 10 | bbb >> (32 - 10));
 771
 772        // HHH(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[14], 6);
 773        ddd += H(eee, aaa, bbb) + blockDWords[14] + 0x6d703ef3;
 774        ddd = (ddd << 6 | ddd >> (32 - 6)) + ccc;
 775        aaa = (aaa << 10 | aaa >> (32 - 10));
 776
 777        // HHH(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[6], 6);
 778        ccc += H(ddd, eee, aaa) + blockDWords[6] + 0x6d703ef3;
 779        ccc = (ccc << 6 | ccc >> (32 - 6)) + bbb;
 780        eee = (eee << 10 | eee >> (32 - 10));
 781
 782        // HHH(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[9], 14);
 783        bbb += H(ccc, ddd, eee) + blockDWords[9] + 0x6d703ef3;
 784        bbb = (bbb << 14 | bbb >> (32 - 14)) + aaa;
 785        ddd = (ddd << 10 | ddd >> (32 - 10));
 786
 787        // HHH(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[11], 12);
 788        aaa += H(bbb, ccc, ddd) + blockDWords[11] + 0x6d703ef3;
 789        aaa = (aaa << 12 | aaa >> (32 - 12)) + eee;
 790        ccc = (ccc << 10 | ccc >> (32 - 10));
 791
 792        // HHH(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[8], 13);
 793        eee += H(aaa, bbb, ccc) + blockDWords[8] + 0x6d703ef3;
 794        eee = (eee << 13 | eee >> (32 - 13)) + ddd;
 795        bbb = (bbb << 10 | bbb >> (32 - 10));
 796
 797        // HHH(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[12], 5);
 798        ddd += H(eee, aaa, bbb) + blockDWords[12] + 0x6d703ef3;
 799        ddd = (ddd << 5 | ddd >> (32 - 5)) + ccc;
 800        aaa = (aaa << 10 | aaa >> (32 - 10));
 801
 802        // HHH(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[2], 14);
 803        ccc += H(ddd, eee, aaa) + blockDWords[2] + 0x6d703ef3;
 804        ccc = (ccc << 14 | ccc >> (32 - 14)) + bbb;
 805        eee = (eee << 10 | eee >> (32 - 10));
 806
 807        // HHH(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[10], 13);
 808        bbb += H(ccc, ddd, eee) + blockDWords[10] + 0x6d703ef3;
 809        bbb = (bbb << 13 | bbb >> (32 - 13)) + aaa;
 810        ddd = (ddd << 10 | ddd >> (32 - 10));
 811
 812        // HHH(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[0], 13);
 813        aaa += H(bbb, ccc, ddd) + blockDWords[0] + 0x6d703ef3;
 814        aaa = (aaa << 13 | aaa >> (32 - 13)) + eee;
 815        ccc = (ccc << 10 | ccc >> (32 - 10));
 816
 817        // HHH(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[4], 7);
 818        eee += H(aaa, bbb, ccc) + blockDWords[4] + 0x6d703ef3;
 819        eee = (eee << 7 | eee >> (32 - 7)) + ddd;
 820        bbb = (bbb << 10 | bbb >> (32 - 10));
 821
 822        // HHH(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[13], 5);
 823        ddd += H(eee, aaa, bbb) + blockDWords[13] + 0x6d703ef3;
 824        ddd = (ddd << 5 | ddd >> (32 - 5)) + ccc;
 825        aaa = (aaa << 10 | aaa >> (32 - 10));
 826
 827        // Parallel Right Round 4
 828        // GGG(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[8], 15);
 829        ccc += G(ddd, eee, aaa) + blockDWords[8] + 0x7a6d76e9;
 830        ccc = (ccc << 15 | ccc >> (32 - 15)) + bbb;
 831        eee = (eee << 10 | eee >> (32 - 10));
 832
 833        // GGG(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[6], 5);
 834        bbb += G(ccc, ddd, eee) + blockDWords[6] + 0x7a6d76e9;
 835        bbb = (bbb << 5 | bbb >> (32 - 5)) + aaa;
 836        ddd = (ddd << 10 | ddd >> (32 - 10));
 837
 838        // GGG(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[4], 8);
 839        aaa += G(bbb, ccc, ddd) + blockDWords[4] + 0x7a6d76e9;
 840        aaa = (aaa << 8 | aaa >> (32 - 8)) + eee;
 841        ccc = (ccc << 10 | ccc >> (32 - 10));
 842
 843        // GGG(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[1], 11);
 844        eee += G(aaa, bbb, ccc) + blockDWords[1] + 0x7a6d76e9;
 845        eee = (eee << 11 | eee >> (32 - 11)) + ddd;
 846        bbb = (bbb << 10 | bbb >> (32 - 10));
 847
 848        // GGG(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[3], 14);
 849        ddd += G(eee, aaa, bbb) + blockDWords[3] + 0x7a6d76e9;
 850        ddd = (ddd << 14 | ddd >> (32 - 14)) + ccc;
 851        aaa = (aaa << 10 | aaa >> (32 - 10));
 852
 853        // GGG(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[11], 14);
 854        ccc += G(ddd, eee, aaa) + blockDWords[11] + 0x7a6d76e9;
 855        ccc = (ccc << 14 | ccc >> (32 - 14)) + bbb;
 856        eee = (eee << 10 | eee >> (32 - 10));
 857
 858        // GGG(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[15], 6);
 859        bbb += G(ccc, ddd, eee) + blockDWords[15] + 0x7a6d76e9;
 860        bbb = (bbb << 6 | bbb >> (32 - 6)) + aaa;
 861        ddd = (ddd << 10 | ddd >> (32 - 10));
 862
 863        // GGG(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[0], 14);
 864        aaa += G(bbb, ccc, ddd) + blockDWords[0] + 0x7a6d76e9;
 865        aaa = (aaa << 14 | aaa >> (32 - 14)) + eee;
 866        ccc = (ccc << 10 | ccc >> (32 - 10));
 867
 868        // GGG(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[5], 6);
 869        eee += G(aaa, bbb, ccc) + blockDWords[5] + 0x7a6d76e9;
 870        eee = (eee << 6 | eee >> (32 - 6)) + ddd;
 871        bbb = (bbb << 10 | bbb >> (32 - 10));
 872
 873        // GGG(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[12], 9);
 874        ddd += G(eee, aaa, bbb) + blockDWords[12] + 0x7a6d76e9;
 875        ddd = (ddd << 9 | ddd >> (32 - 9)) + ccc;
 876        aaa = (aaa << 10 | aaa >> (32 - 10));
 877
 878        // GGG(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[2], 12);
 879        ccc += G(ddd, eee, aaa) + blockDWords[2] + 0x7a6d76e9;
 880        ccc = (ccc << 12 | ccc >> (32 - 12)) + bbb;
 881        eee = (eee << 10 | eee >> (32 - 10));
 882
 883        // GGG(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[13], 9);
 884        bbb += G(ccc, ddd, eee) + blockDWords[13] + 0x7a6d76e9;
 885        bbb = (bbb << 9 | bbb >> (32 - 9)) + aaa;
 886        ddd = (ddd << 10 | ddd >> (32 - 10));
 887
 888        // GGG(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[9], 12);
 889        aaa += G(bbb, ccc, ddd) + blockDWords[9] + 0x7a6d76e9;
 890        aaa = (aaa << 12 | aaa >> (32 - 12)) + eee;
 891        ccc = (ccc << 10 | ccc >> (32 - 10));
 892
 893        // GGG(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[7], 5);
 894        eee += G(aaa, bbb, ccc) + blockDWords[7] + 0x7a6d76e9;
 895        eee = (eee << 5 | eee >> (32 - 5)) + ddd;
 896        bbb = (bbb << 10 | bbb >> (32 - 10));
 897
 898        // GGG(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[10], 15);
 899        ddd += G(eee, aaa, bbb) + blockDWords[10] + 0x7a6d76e9;
 900        ddd = (ddd << 15 | ddd >> (32 - 15)) + ccc;
 901        aaa = (aaa << 10 | aaa >> (32 - 10));
 902
 903        // GGG(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[14], 8);
 904        ccc += G(ddd, eee, aaa) + blockDWords[14] + 0x7a6d76e9;
 905        ccc = (ccc << 8 | ccc >> (32 - 8)) + bbb;
 906        eee = (eee << 10 | eee >> (32 - 10));
 907
 908        // Parallel Right Round 5
 909        // FFF(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[12], 8);
 910        bbb += F(ccc, ddd, eee) + blockDWords[12];
 911        bbb = (bbb << 8 | bbb >> (32 - 8)) + aaa;
 912        ddd = (ddd << 10 | ddd >> (32 - 10));
 913
 914        // FFF(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[15], 5);
 915        aaa += F(bbb, ccc, ddd) + blockDWords[15];
 916        aaa = (aaa << 5 | aaa >> (32 - 5)) + eee;
 917        ccc = (ccc << 10 | ccc >> (32 - 10));
 918
 919        // FFF(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[10], 12);
 920        eee += F(aaa, bbb, ccc) + blockDWords[10];
 921        eee = (eee << 12 | eee >> (32 - 12)) + ddd;
 922        bbb = (bbb << 10 | bbb >> (32 - 10));
 923
 924        // FFF(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[4], 9);
 925        ddd += F(eee, aaa, bbb) + blockDWords[4];
 926        ddd = (ddd << 9 | ddd >> (32 - 9)) + ccc;
 927        aaa = (aaa << 10 | aaa >> (32 - 10));
 928
 929        // FFF(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[1], 12);
 930        ccc += F(ddd, eee, aaa) + blockDWords[1];
 931        ccc = (ccc << 12 | ccc >> (32 - 12)) + bbb;
 932        eee = (eee << 10 | eee >> (32 - 10));
 933
 934        // FFF(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[5], 5);
 935        bbb += F(ccc, ddd, eee) + blockDWords[5];
 936        bbb = (bbb << 5 | bbb >> (32 - 5)) + aaa;
 937        ddd = (ddd << 10 | ddd >> (32 - 10));
 938
 939        // FFF(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[8], 14);
 940        aaa += F(bbb, ccc, ddd) + blockDWords[8];
 941        aaa = (aaa << 14 | aaa >> (32 - 14)) + eee;
 942        ccc = (ccc << 10 | ccc >> (32 - 10));
 943
 944        // FFF(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[7], 6);
 945        eee += F(aaa, bbb, ccc) + blockDWords[7];
 946        eee = (eee << 6 | eee >> (32 - 6)) + ddd;
 947        bbb = (bbb << 10 | bbb >> (32 - 10));
 948
 949        // FFF(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[6], 8);
 950        ddd += F(eee, aaa, bbb) + blockDWords[6];
 951        ddd = (ddd << 8 | ddd >> (32 - 8)) + ccc;
 952        aaa = (aaa << 10 | aaa >> (32 - 10));
 953
 954        // FFF(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[2], 13);
 955        ccc += F(ddd, eee, aaa) + blockDWords[2];
 956        ccc = (ccc << 13 | ccc >> (32 - 13)) + bbb;
 957        eee = (eee << 10 | eee >> (32 - 10));
 958
 959        // FFF(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[13], 6);
 960        bbb += F(ccc, ddd, eee) + blockDWords[13];
 961        bbb = (bbb << 6 | bbb >> (32 - 6)) + aaa;
 962        ddd = (ddd << 10 | ddd >> (32 - 10));
 963
 964        // FFF(ref aaa, ref bbb, ref ccc, ref ddd, ref eee, blockDWords[14], 5);
 965        aaa += F(bbb, ccc, ddd) + blockDWords[14];
 966        aaa = (aaa << 5 | aaa >> (32 - 5)) + eee;
 967        ccc = (ccc << 10 | ccc >> (32 - 10));
 968
 969        // FFF(ref eee, ref aaa, ref bbb, ref ccc, ref ddd, blockDWords[0], 15);
 970        eee += F(aaa, bbb, ccc) + blockDWords[0];
 971        eee = (eee << 15 | eee >> (32 - 15)) + ddd;
 972        bbb = (bbb << 10 | bbb >> (32 - 10));
 973
 974        // FFF(ref ddd, ref eee, ref aaa, ref bbb, ref ccc, blockDWords[3], 13);
 975        ddd += F(eee, aaa, bbb) + blockDWords[3];
 976        ddd = (ddd << 13 | ddd >> (32 - 13)) + ccc;
 977        aaa = (aaa << 10 | aaa >> (32 - 10));
 978
 979        // FFF(ref ccc, ref ddd, ref eee, ref aaa, ref bbb, blockDWords[9], 11);
 980        ccc += F(ddd, eee, aaa) + blockDWords[9];
 981        ccc = (ccc << 11 | ccc >> (32 - 11)) + bbb;
 982        eee = (eee << 10 | eee >> (32 - 10));
 983
 984        // FFF(ref bbb, ref ccc, ref ddd, ref eee, ref aaa, blockDWords[11], 11);
 985        bbb += F(ccc, ddd, eee) + blockDWords[11];
 986        bbb = (bbb << 11 | bbb >> (32 - 11)) + aaa;
 987        ddd = (ddd << 10 | ddd >> (32 - 10));
 988
 989        // Update the state of the hash object
 990        ddd += cc + state[1];
 991        state[1] = state[2] + dd + eee;
 992        state[2] = state[3] + ee + aaa;
 993        state[3] = state[4] + aa + bbb;
 994        state[4] = state[0] + bb + ccc;
 995        state[0] = ddd;
 996    }
 997
 998    // The five basic functions
 999    private static uint F (uint x, uint y, uint z) {
 1000        return (x ^ y ^ z);
 1001    }
 1002
 1003    private static uint G (uint x, uint y, uint z) {
 1004        return ((x & y) | (~x & z));
 1005    }
 1006
 1007    private static uint H (uint x, uint y, uint z) {
 1008        return ((x | ~y) ^ z);
 1009    }
 1010
 1011    private static uint I (uint x, uint y, uint z) {
 1012        return ((x & z) | (y & ~z));
 1013    }
 1014
 1015    private static uint J (uint x, uint y, uint z) {
 1016        return (x ^ (y | ~z));
 1017    }
 1018}
 1019
 1020// Utils.cs
 1021internal static partial class Utils {
 1022    // https://github.com/microsoft/referencesource/blob/51cf7850defa8a17d815b4700b67116e3fa283c2/mscorlib/system/securi
 1023
 1024    // digits == number of DWORDs
 11025    internal static void DWORDFromLittleEndian (uint[] x, int digits, byte[] block) {
 1026        int i;
 1027        int j;
 1028
 11029        for (i = 0, j = 0; i < digits; i++, j += 4)
 11030            x[i] =  (uint) (block[j] | (block[j+1] << 8) | (block[j+2] << 16) | (block[j+3] << 24));
 11031    }
 1032
 1033    // encodes x (DWORD) into block (unsigned char), least significant byte first.
 1034    // digits == number of DWORDs
 11035    internal static void DWORDToLittleEndian (byte[] block, uint[] x, int digits) {
 1036        int i;
 1037        int j;
 1038
 11039        for (i = 0, j = 0; i < digits; i++, j += 4) {
 11040            block[j]   = (byte)(x[i] & 0xff);
 11041            block[j+1] = (byte)((x[i] >> 8) & 0xff);
 11042            block[j+2] = (byte)((x[i] >> 16) & 0xff);
 11043            block[j+3] = (byte)((x[i] >> 24) & 0xff);
 11044        }
 11045    }
 1046}
Generated by: ReportGenerator 5.4.5.0
05/02/2025 - 12:40:04
GitHub | reportgenerator.io

Methods/Properties

DWORDFromLittleEndian(uint[], int, byte[])
DWORDToLittleEndian(byte[], uint[], int)