Changeset 1127


Ignore:
Timestamp:
Feb 2, 2010, 2:38:19 PM (12 years ago)
Author:
pretzsch
Message:

+ MD5Collider: Stop()-Funktion, Refactoring

Location:
trunk/CrypPlugins/MD5Collider
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/MD5Collider/Algorithm/IMD5ColliderAlgorithm.cs

    r1055 r1127  
    1313
    1414        void FindCollision();
     15
     16        void Stop();
    1517    }
    1618}
  • trunk/CrypPlugins/MD5Collider/Algorithm/KlimaTunnelsCollider.cs

    r1055 r1127  
    13461346                }//Q10
    13471347            }//Q16Q17
    1348             return (-1);//kolize NEnalezena;
    13491348        }
    13501349        /*=========================================================*/
     
    16991698        /*=========================================================*/
    17001699
     1700
     1701        #region IMD5ColliderAlgorithm Member
     1702
     1703
     1704        public void Stop()
     1705        {
     1706            throw new NotImplementedException();
     1707        }
     1708
     1709        #endregion
    17011710    }
    17021711}
  • trunk/CrypPlugins/MD5Collider/Algorithm/StevensCollider.cs

    r1055 r1127  
    44using System.Text;
    55using System.Security.Cryptography;
     6using System.Threading;
    67
    78namespace Cryptool.MD5Collider.Algorithm
     
    1718        public void FindCollision()
    1819        {
     20            IsStopped = false;
     21
    1922            byte[] seedBytesMd5 = MD5.Create().ComputeHash(RandomSeed);
    2023            seed32_1 = (UInt32)(BitConverter.ToInt32(seedBytesMd5, 0) ^ BitConverter.ToInt32(seedBytesMd5, 4));
     
    2932            UInt32[] m1b0 = new UInt32[16], m1b1 = new UInt32[16], m2b0 = new UInt32[16], m2b1 = new UInt32[16];
    3033            find_collision(standardIV, m1b0, m1b1, m2b0, m2b1);
     34
     35            if (IsStopped)
     36                return;
    3137
    3238            byte[] firstMessage = new byte[128];
     
    7480            find_block0(msg1block0, IV);
    7581
     82            if (IsStopped)
     83                return;
     84
    7685            UInt32[] IHV = new[] { IV[0], IV[1], IV[2], IV[3] };
    7786            md5_compress(IHV, msg1block0);
    7887
    7988            find_block1(msg1block1, IHV);
     89
     90            if (IsStopped)
     91                return;
    8092
    8193            for (int t = 0; t < 16; ++t)
     
    148160            while (true)
    149161            {
     162                if (IsStopped)
     163                    return;
     164
    150165                Q[Qoff + 1] = xrng64();
    151166                Q[Qoff + 3] = (xrng64() & 0xfe87bc3f) | 0x017841c0;
     
    182197                while (counter < (1 << 7))
    183198                {
     199                    if (IsStopped)
     200                        return;
     201
    184202                    UInt32 q16 = Q[Qoff + 16];
    185203                    UInt32 q17 = ((xrng64() & 0x3ffd7ff7) | (q16 & 0xc0008008)) ^ 0x40000000;
     
    228246                while (counter2 < (1 << 4))
    229247                {
     248                    if (IsStopped)
     249                        return;
     250
    230251                    Q[Qoff + 4] = q4 ^ q4mask[counter2];
    231252                    ++counter2;
     
    257278                    for (UInt32 counter3 = 0; counter3 < (1 << 3); )
    258279                    {
     280                        if (IsStopped)
     281                            return;
     282
    259283                        UInt32 q10 = Q[Qoff + 10] ^ (q9q10mask[counter3] & 0x60);
    260284                        Q[Qoff + 9] = q9backup ^ (q9q10mask[counter3] & 0x2000);
     
    284308                        for (UInt32 counter4 = 0; counter4 < (1 << 16); ++counter4)
    285309                        {
     310                            if (IsStopped)
     311                                return;
     312
    286313                            UInt32 q9 = Q[Qoff + 9] ^ q9mask[counter4];
    287314                            block[12] = tt12 - FF(Q[Qoff + 12], Q[Qoff + 11], q10) - q9;
     
    537564            while (true)
    538565            {
     566                if (IsStopped)
     567                    return;
     568
    539569                UInt32 aa1 = Q[Qoff] & 0x80000000;
    540570
     
    573603                while (counter < (1 << 12))
    574604                {
     605                    if (IsStopped)
     606                        return;
     607
    575608                    ++counter;
    576609
     
    636669                for (UInt32 k10 = 0; k10 < (1 << 3); ++k10)
    637670                {
     671                    if (IsStopped)
     672                        return;
     673
    638674                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000020);
    639675                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    662698                    for (UInt32 k9 = 0; k9 < (1 << 9); ++k9)
    663699                    {
     700                        if (IsStopped)
     701                            return;
     702
    664703                        UInt32 a = aa, b = bb, c = cc, d = dd;
    665704                        Q[Qoff + 9] = q9 ^ q9mask[k9];
     
    762801
    763802        void find_block1_stevens_01(UInt32[] block, UInt32[] IV)
    764 {
    765         UInt32[] Q = new UInt32[68];
    766         Q[0] = IV[0];
    767         Q[1] = IV[3];
    768         Q[2] = IV[2];
    769         Q[3] = IV[1];
    770 
    771         UInt32[] q9q10mask = new UInt32[1<<5];
    772         for (UInt32 k = 0; k < q9q10mask.Length; ++k)
    773                 q9q10mask[k] = ((k<<4) ^ (k<<11) ^ (k<<24) ^ (k<<27)) & 0x88002030;
    774        
    775         UInt32[] q9mask= new UInt32[1<<9];
    776         for (UInt32 k = 0; k < q9mask.Length; ++k)
    777                 q9mask[k] = ((k<<1) ^ (k<<7) ^ (k<<9) ^ (k<<12) ^ (k<<15) ^ (k<<19) ^ (k<<22)) & 0x44310d02;
    778        
    779         while (true)
    780         {
    781                 UInt32 aa1 = Q[Qoff] & 0x80000000;
    782 
    783                 Q[Qoff + 2] = (xrng64() & 0x4db0e03e) | 0x32460441 | aa1;
    784                 Q[Qoff + 3] = (xrng64() & 0x0c000008) | 0x123c3af1 | (Q[Qoff + 2] & 0x80800002);
    785                 Q[Qoff + 4] = 0xe398f812 ^ (Q[Qoff + 3] & 0x88000000);
    786                 Q[Qoff + 5] = (xrng64() & 0x82000000) | 0x4c66e99e;
    787                 Q[Qoff + 6] = (xrng64() & 0x80000000) | 0x27180590;
    788                 Q[Qoff + 7] = (xrng64() & 0x00010130) | 0x51ea9e47;
    789                 Q[Qoff + 8] = (xrng64() & 0x40200800) | 0xb7c291e5;
    790                 Q[Qoff + 9] = (xrng64() & 0x00044000) | 0x380002b4;
    791                 Q[Qoff +10] = 0xb282b208 | (Q[Qoff + 9] & 0x00044000);
    792                 Q[Qoff +11] = (xrng64() & 0x12808008) | 0xc5712f47;
    793                 Q[Qoff +12] = (xrng64() & 0x1ef18d7f) | 0x000a3080;
    794                 Q[Qoff +13] = (xrng64() & 0x1efb1d77) | 0x4004c008;
    795                 Q[Qoff +14] = (xrng64() & 0x1fff5d77) | 0x6000a288;
    796                 Q[Qoff +15] = (xrng64() & 0x1efe7ff7) | 0xa0008000 | (~Q[Qoff + 14] & 0x00010000);
    797                 Q[Qoff +16] = (xrng64() & 0x1ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x00020000);
    798                
    799                 MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    800                 MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
    801                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    802                 MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
    803                 MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
    804                 MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
    805 
    806                 UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
    807                 UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
    808                 UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
    809 
    810                 UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
    811                 UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;         
    812 
    813                 UInt32 q1a = 0x02000021 ^ (Q[Qoff + 0] & 0x80000020);
    814                
    815                 UInt32 counter = 0;
    816                 while (counter < (1 << 12))
    817                 {
    818                         ++counter;
    819 
    820                         UInt32 q1 = q1a | (xrng64() & 0x7dfff39e);
    821                         UInt32 m1 = Q[Qoff+2] - q1;
    822                         m1 = RR(m1, 12) - FF(q1, Q[Qoff+0], Q[Qoff-1]) - tt1;
    823 
    824                         UInt32 q16 = Q[Qoff+16];
    825                         UInt32 q17 = tt17 + m1;
    826                         q17 = RL(q17, 5) + q16;
    827                         if (0x80000000 != ((q17^q16) & 0x80008008)) continue;
    828                         if (0 != (q17 & 0x00020000)) continue;
    829 
    830                         UInt32 q18 = GG(q17, q16, Q[Qoff+15]) + tt18;
    831                         q18 = RL(q18, 9); q18 += q17;
    832                         if (0x80020000 != ((q18^q17) & 0xa0020000)) continue;
    833 
    834                         UInt32 q19 = GG(q18, q17, q16) + tt19;
    835                         q19 = RL(q19, 14); q19 += q18;
    836                         if (0 != (q19 & 0x80020000)) continue;
    837 
    838                         UInt32 m0 = q1 - Q[Qoff + 0];
    839                         m0 = RR(m0, 7) - tt0;
    840 
    841                         UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    842                         q20 = RL(q20, 20); q20 += q19;
    843                         if (0x00040000 != ((q20^q19) & 0x80040000))     continue;
    844                        
    845                         Q[Qoff + 1] = q1;
    846                         Q[Qoff + 17] = q17;
    847                         Q[Qoff + 18] = q18;
    848                         Q[Qoff + 19] = q19;
    849                         Q[Qoff + 20] = q20;
    850 
    851                         block[0] = m0;
    852                         block[1] = m1;
    853 
    854                         MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    855                         UInt32 q21 = GG(Q[Qoff+20], Q[Qoff+19], Q[Qoff+18]) + Q[Qoff+17] + 0xd62f105d + block[5];
    856                         q21 = RL(q21, 5); q21 += Q[Qoff+20];
    857                         if (0 != ((q21^Q[Qoff+20]) & 0x80020000)) continue;
    858 
    859                         Q[Qoff+21] = q21;
    860 
    861                         counter = 0;
    862                         break;
    863                 }
    864                 if (counter != 0)
    865                         continue;
    866 
    867                 UInt32 q9b = Q[Qoff + 9];
    868                 UInt32 q10b = Q[Qoff + 10];
    869 
    870                 MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
    871                 MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
    872                 MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
    873                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    874 
    875                 UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
    876                 UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
    877                 UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
    878                 UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
    879          
    880                 for (UInt32 k10 = 0; k10 < (1<<5); ++k10)
    881                 {
    882                         UInt32 q10 = q10b | (q9q10mask[k10]&0x08000030);
    883                         UInt32 m10 = RR(Q[Qoff+11]-q10,17);
    884                         UInt32 q9 = q9b | (q9q10mask[k10]&0x80002000);
    885 
    886                         m10 -= FF(q10, q9, Q[Qoff+8]) + tt10;
    887 
    888                         UInt32 aa = Q[Qoff + 21];
    889                         UInt32 dd = tt22+m10; dd = RL(dd, 9) + aa;
    890                         if (0 != (dd & 0x80000000)) continue;                   
    891 
    892                         UInt32 bb = Q[Qoff + 20];
    893                         UInt32 cc = tt23 + GG(dd, aa, bb);
    894                         if (0 != (cc & 0x20000)) continue;
    895                         cc = RL(cc, 14) + dd;
    896                         if (0 != (cc & 0x80000000)) continue;
    897 
    898                         bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    899                         if (0 == (bb & 0x80000000)) continue;
    900 
    901                         block[10] = m10;
    902                         Q[Qoff + 9] = q9;
    903                         Q[Qoff + 10] = q10;
    904                         MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
    905 
    906                         for (UInt32 k9 = 0; k9 < (1<<9); ++k9)
    907                         {
    908                                 UInt32 a = aa, b = bb, c = cc, d = dd;
    909                                 Q[Qoff + 9] = q9 ^ q9mask[k9];
    910                                 MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
    911                                 MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
    912                                 MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    913 
    914                                 MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    915                                 MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    916                                 MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    917                                 MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    918                                 MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    919                                 MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    920                                 MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    921                                 MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    922                                 MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    923                                 MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
    924 
    925                                 c += HH(d, a, b) + block[11] + 0x6d9d6122;
    926                                 if (0 != (c & (1 << 15)))
    927                                         continue;
    928                                 c = (c<<16 | c>>16) + d;
    929                                        
    930                                 MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    931                                 MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    932                                 MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    933                                 MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    934                                 MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    935                                 MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    936                                 MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    937                                 MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    938                                 MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    939                                 MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    940                                 MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    941                                 MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    942                                 MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    943                                 if (0 != ((b^d) & 0x80000000))
    944                                         continue;
    945 
    946                                 MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    947                                 if (0 != ((a^c) >> 31)) continue;
    948                                 MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    949                                 if (0 == ((b^d) >> 31)) continue;
    950                                 MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    951                                 if (0 != ((a^c) >> 31)) continue;
    952                                 MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    953                                 if (0 != ((b^d) >> 31)) continue;
    954                                 MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    955                                 if (0 != ((a^c) >> 31)) continue;
    956                                 MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    957                                 if (0 != ((b^d) >> 31)) continue;
    958                                 MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    959                                 if (0 != ((a^c) >> 31)) continue;
    960                                 MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    961                                 if (0 != ((b^d) >> 31)) continue;
    962                                 MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    963                                 if (0 != ((a^c) >> 31)) continue;
    964                                 MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    965                                 if (0 != ((b^d) >> 31)) continue;
    966                                 MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    967                                 if (0 != ((a^c) >> 31)) continue;
    968                                 MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    969                                 if (0 == ((b^d) >> 31)) continue;
    970                                 MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    971                                 if (0 != ((a^c) >> 31)) continue;
    972                                 MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    973                                 if (0 != ((b^d) >> 31)) continue;
    974                                 MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    975                                 if (0 != ((a^c) >> 31)) continue;
    976                                 MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    977 
    978                                 UInt32[] block2 = new UInt32[16];
    979                                 UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
    980                                 for (int t = 0; t < 4; ++t)
    981                                 {
    982                                         IV1[t] = IV[t];
    983                                         IV2[t] = IV[t] + ((UInt32)1 << 31);
    984                                 }
    985                                 IV2[1] -= (1 << 25);
    986                                 IV2[2] -= (1 << 25);
    987                                 IV2[3] -= (1 << 25);
    988 
    989                                 for (int t = 0; t < 16; ++t)
    990                                         block2[t] = block[t];
    991                                 block2[4] += (UInt32)1<<31;
    992                                 block2[11] += 1<<15;
    993                                 block2[14] += (UInt32)1<<31;
    994 
    995                                 md5_compress(IV1, block);
    996                                 md5_compress(IV2, block2);
    997                                 if (IV2[0]==IV1[0] && IV2[1]==IV1[1] && IV2[2]==IV1[2] && IV2[3]==IV1[3])
    998                                         return;
    999 
    1000                                 //if (IV2[0] != IV1[0])
    1001                                 //              std::cout << "!" << std::flush;
    1002                         }
    1003                 }
    1004         }
    1005 }
     803        {
     804            UInt32[] Q = new UInt32[68];
     805            Q[0] = IV[0];
     806            Q[1] = IV[3];
     807            Q[2] = IV[2];
     808            Q[3] = IV[1];
     809
     810            UInt32[] q9q10mask = new UInt32[1 << 5];
     811            for (UInt32 k = 0; k < q9q10mask.Length; ++k)
     812                q9q10mask[k] = ((k << 4) ^ (k << 11) ^ (k << 24) ^ (k << 27)) & 0x88002030;
     813
     814            UInt32[] q9mask = new UInt32[1 << 9];
     815            for (UInt32 k = 0; k < q9mask.Length; ++k)
     816                q9mask[k] = ((k << 1) ^ (k << 7) ^ (k << 9) ^ (k << 12) ^ (k << 15) ^ (k << 19) ^ (k << 22)) & 0x44310d02;
     817
     818            while (true)
     819            {
     820                if (IsStopped)
     821                    return;
     822
     823                UInt32 aa1 = Q[Qoff] & 0x80000000;
     824
     825                Q[Qoff + 2] = (xrng64() & 0x4db0e03e) | 0x32460441 | aa1;
     826                Q[Qoff + 3] = (xrng64() & 0x0c000008) | 0x123c3af1 | (Q[Qoff + 2] & 0x80800002);
     827                Q[Qoff + 4] = 0xe398f812 ^ (Q[Qoff + 3] & 0x88000000);
     828                Q[Qoff + 5] = (xrng64() & 0x82000000) | 0x4c66e99e;
     829                Q[Qoff + 6] = (xrng64() & 0x80000000) | 0x27180590;
     830                Q[Qoff + 7] = (xrng64() & 0x00010130) | 0x51ea9e47;
     831                Q[Qoff + 8] = (xrng64() & 0x40200800) | 0xb7c291e5;
     832                Q[Qoff + 9] = (xrng64() & 0x00044000) | 0x380002b4;
     833                Q[Qoff + 10] = 0xb282b208 | (Q[Qoff + 9] & 0x00044000);
     834                Q[Qoff + 11] = (xrng64() & 0x12808008) | 0xc5712f47;
     835                Q[Qoff + 12] = (xrng64() & 0x1ef18d7f) | 0x000a3080;
     836                Q[Qoff + 13] = (xrng64() & 0x1efb1d77) | 0x4004c008;
     837                Q[Qoff + 14] = (xrng64() & 0x1fff5d77) | 0x6000a288;
     838                Q[Qoff + 15] = (xrng64() & 0x1efe7ff7) | 0xa0008000 | (~Q[Qoff + 14] & 0x00010000);
     839                Q[Qoff + 16] = (xrng64() & 0x1ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x00020000);
     840
     841                MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     842                MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
     843                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     844                MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
     845                MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
     846                MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
     847
     848                UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
     849                UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
     850                UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
     851
     852                UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
     853                UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;
     854
     855                UInt32 q1a = 0x02000021 ^ (Q[Qoff + 0] & 0x80000020);
     856
     857                UInt32 counter = 0;
     858                while (counter < (1 << 12))
     859                {
     860                    if (IsStopped)
     861                        return;
     862
     863                    ++counter;
     864
     865                    UInt32 q1 = q1a | (xrng64() & 0x7dfff39e);
     866                    UInt32 m1 = Q[Qoff + 2] - q1;
     867                    m1 = RR(m1, 12) - FF(q1, Q[Qoff + 0], Q[Qoff - 1]) - tt1;
     868
     869                    UInt32 q16 = Q[Qoff + 16];
     870                    UInt32 q17 = tt17 + m1;
     871                    q17 = RL(q17, 5) + q16;
     872                    if (0x80000000 != ((q17 ^ q16) & 0x80008008)) continue;
     873                    if (0 != (q17 & 0x00020000)) continue;
     874
     875                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
     876                    q18 = RL(q18, 9); q18 += q17;
     877                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     878
     879                    UInt32 q19 = GG(q18, q17, q16) + tt19;
     880                    q19 = RL(q19, 14); q19 += q18;
     881                    if (0 != (q19 & 0x80020000)) continue;
     882
     883                    UInt32 m0 = q1 - Q[Qoff + 0];
     884                    m0 = RR(m0, 7) - tt0;
     885
     886                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
     887                    q20 = RL(q20, 20); q20 += q19;
     888                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     889
     890                    Q[Qoff + 1] = q1;
     891                    Q[Qoff + 17] = q17;
     892                    Q[Qoff + 18] = q18;
     893                    Q[Qoff + 19] = q19;
     894                    Q[Qoff + 20] = q20;
     895
     896                    block[0] = m0;
     897                    block[1] = m1;
     898
     899                    MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     900                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
     901                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
     902                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     903
     904                    Q[Qoff + 21] = q21;
     905
     906                    counter = 0;
     907                    break;
     908                }
     909                if (counter != 0)
     910                    continue;
     911
     912                UInt32 q9b = Q[Qoff + 9];
     913                UInt32 q10b = Q[Qoff + 10];
     914
     915                MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
     916                MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
     917                MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
     918                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     919
     920                UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
     921                UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
     922                UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
     923                UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
     924
     925                for (UInt32 k10 = 0; k10 < (1 << 5); ++k10)
     926                {
     927                    if (IsStopped)
     928                        return;
     929
     930                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000030);
     931                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     932                    UInt32 q9 = q9b | (q9q10mask[k10] & 0x80002000);
     933
     934                    m10 -= FF(q10, q9, Q[Qoff + 8]) + tt10;
     935
     936                    UInt32 aa = Q[Qoff + 21];
     937                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
     938                    if (0 != (dd & 0x80000000)) continue;
     939
     940                    UInt32 bb = Q[Qoff + 20];
     941                    UInt32 cc = tt23 + GG(dd, aa, bb);
     942                    if (0 != (cc & 0x20000)) continue;
     943                    cc = RL(cc, 14) + dd;
     944                    if (0 != (cc & 0x80000000)) continue;
     945
     946                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
     947                    if (0 == (bb & 0x80000000)) continue;
     948
     949                    block[10] = m10;
     950                    Q[Qoff + 9] = q9;
     951                    Q[Qoff + 10] = q10;
     952                    MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
     953
     954                    for (UInt32 k9 = 0; k9 < (1 << 9); ++k9)
     955                    {
     956                        if (IsStopped)
     957                            return;
     958
     959                        UInt32 a = aa, b = bb, c = cc, d = dd;
     960                        Q[Qoff + 9] = q9 ^ q9mask[k9];
     961                        MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
     962                        MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
     963                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
     964
     965                        MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
     966                        MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
     967                        MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
     968                        MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
     969                        MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
     970                        MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     971                        MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
     972                        MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     973                        MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
     974                        MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     975
     976                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     977                        if (0 != (c & (1 << 15)))
     978                            continue;
     979                        c = (c << 16 | c >> 16) + d;
     980
     981                        MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
     982                        MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
     983                        MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     984                        MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     985                        MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
     986                        MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
     987                        MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
     988                        MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
     989                        MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
     990                        MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
     991                        MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
     992                        MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     993                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     994                        if (0 != ((b ^ d) & 0x80000000))
     995                            continue;
     996
     997                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     998                        if (0 != ((a ^ c) >> 31)) continue;
     999                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1000                        if (0 == ((b ^ d) >> 31)) continue;
     1001                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1002                        if (0 != ((a ^ c) >> 31)) continue;
     1003                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1004                        if (0 != ((b ^ d) >> 31)) continue;
     1005                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1006                        if (0 != ((a ^ c) >> 31)) continue;
     1007                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1008                        if (0 != ((b ^ d) >> 31)) continue;
     1009                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1010                        if (0 != ((a ^ c) >> 31)) continue;
     1011                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1012                        if (0 != ((b ^ d) >> 31)) continue;
     1013                        MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     1014                        if (0 != ((a ^ c) >> 31)) continue;
     1015                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1016                        if (0 != ((b ^ d) >> 31)) continue;
     1017                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1018                        if (0 != ((a ^ c) >> 31)) continue;
     1019                        MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
     1020                        if (0 == ((b ^ d) >> 31)) continue;
     1021                        MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     1022                        if (0 != ((a ^ c) >> 31)) continue;
     1023                        MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     1024                        if (0 != ((b ^ d) >> 31)) continue;
     1025                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1026                        if (0 != ((a ^ c) >> 31)) continue;
     1027                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1028
     1029                        UInt32[] block2 = new UInt32[16];
     1030                        UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
     1031                        for (int t = 0; t < 4; ++t)
     1032                        {
     1033                            IV1[t] = IV[t];
     1034                            IV2[t] = IV[t] + ((UInt32)1 << 31);
     1035                        }
     1036                        IV2[1] -= (1 << 25);
     1037                        IV2[2] -= (1 << 25);
     1038                        IV2[3] -= (1 << 25);
     1039
     1040                        for (int t = 0; t < 16; ++t)
     1041                            block2[t] = block[t];
     1042                        block2[4] += (UInt32)1 << 31;
     1043                        block2[11] += 1 << 15;
     1044                        block2[14] += (UInt32)1 << 31;
     1045
     1046                        md5_compress(IV1, block);
     1047                        md5_compress(IV2, block2);
     1048                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1049                            return;
     1050
     1051                        //if (IV2[0] != IV1[0])
     1052                        //              std::cout << "!" << std::flush;
     1053                    }
     1054                }
     1055            }
     1056        }
    10061057
    10071058
    10081059        void find_block1_stevens_10(UInt32[] block, UInt32[] IV)
    1009 {
    1010         UInt32[] Q = new UInt32[68];
    1011         Q[0] = IV[0];
    1012         Q[1] = IV[3];
    1013         Q[2] = IV[2];
    1014         Q[3] = IV[1];
    1015 
    1016         UInt32[] q9q10mask = new UInt32[1<<4];
    1017         for (UInt32 k = 0; k < q9q10mask.Length; ++k)
    1018                 q9q10mask[k] = ((k<<2) ^ (k<<8) ^ (k<<11) ^ (k<<25)) & 0x08004204;
    1019        
    1020         UInt32[] q9mask= new UInt32[1<<10];
    1021         for (UInt32 k = 0; k < q9mask.Length; ++k)
    1022                 q9mask[k] = ((k<<1) ^ (k<<2) ^ (k<<3) ^ (k<<7) ^ (k<<12) ^ (k<<15) ^ (k<<18) ^ (k<<20)) & 0x2471042a;
    1023        
    1024         while (true)
    1025         {
    1026                 UInt32 aa1 = Q[Qoff] & 0x80000000;
    1027 
    1028                 Q[Qoff + 2] = (xrng64() & 0x79b0c6ba) | 0x024c3841 | aa1;
    1029                 Q[Qoff + 3] = (xrng64() & 0x19300210) | 0x2603096d | (Q[Qoff + 2] & 0x80000082);
    1030                 Q[Qoff + 4] = (xrng64() & 0x10300000) | 0xe4cae30c | (Q[Qoff + 3] & 0x01000030);
    1031                 Q[Qoff + 5] = (xrng64() & 0x10000000) | 0x63494061 | (Q[Qoff + 4] & 0x00300000);
    1032                 Q[Qoff + 6] = 0x7deaff68;
    1033                 Q[Qoff + 7] = (xrng64() & 0x20444000) | 0x09091ee0;
    1034                 Q[Qoff + 8] = (xrng64() & 0x09040000) | 0xb2529f6d;
    1035                 Q[Qoff + 9] = (xrng64() & 0x00040000) | 0x10885184;
    1036                 Q[Qoff + 10] = (xrng64() & 0x00000080) | 0x428afb11 | (Q[Qoff + 9] & 0x00040000);
    1037                 Q[Qoff + 11] = (xrng64() & 0x128a8110) | 0x6571266b | (Q[Qoff + 10] & 0x0000080);
    1038                 Q[Qoff + 12] = (xrng64() & 0x3ef38d7f) | 0x00003080 | (~Q[Qoff + 11] & 0x00080000);
    1039                 Q[Qoff + 13] = (xrng64() & 0x3efb1d77) | 0x0004c008;
    1040                 Q[Qoff + 14] = (xrng64() & 0x5fff5d77) | 0x8000a288;
    1041                 Q[Qoff + 15] = (xrng64() & 0x1efe7ff7) | 0xe0008000 | (~Q[Qoff + 14] & 0x00010000);
    1042                 Q[Qoff + 16] = (xrng64() & 0x5ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x00020000);
    1043 
    1044                 MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    1045                 MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
    1046                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    1047                 MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
    1048                 MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
    1049                 MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
    1050 
    1051                  UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
    1052                  UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
    1053                  UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
    1054 
    1055                  UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
    1056                  UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;         
    1057 
    1058                  UInt32 q1a = 0x02000941 ^ (Q[Qoff + 0] & 0x80000000);
    1059                
    1060                 UInt32 counter = 0;
    1061                 while (counter < (1 << 12))
    1062                 {
    1063                         ++counter;
    1064 
    1065                         UInt32 q1 = q1a | (xrng64() & 0x7dfdf6be);
    1066                         UInt32 m1 = Q[Qoff+2] - q1;
    1067                         m1 = RR(m1, 12) - FF(q1, Q[Qoff+0], Q[Qoff-1]) - tt1;
    1068 
    1069                          UInt32 q16 = Q[Qoff+16];
    1070                         UInt32 q17 = tt17 + m1;
    1071                         q17 = RL(q17, 5) + q16;
    1072                         if (0x80000000 != ((q17^q16) & 0x80008008)) continue;
    1073                         if (0 != (q17 & 0x00020000)) continue;
    1074 
    1075                         UInt32 q18 = GG(q17, q16, Q[Qoff+15]) + tt18;
    1076                         q18 = RL(q18, 9); q18 += q17;
    1077                         if (0x80020000 != ((q18^q17) & 0xa0020000)) continue;
    1078 
    1079                         UInt32 q19 = GG(q18, q17, q16) + tt19;
    1080                         q19 = RL(q19, 14); q19 += q18;
    1081                         if (0 != (q19 & 0x80020000)) continue;
    1082 
    1083                         UInt32 m0 = q1 - Q[Qoff + 0];
    1084                         m0 = RR(m0, 7) - tt0;
    1085 
    1086                         UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    1087                         q20 = RL(q20, 20); q20 += q19;
    1088                         if (0x00040000 != ((q20^q19) & 0x80040000))     continue;
    1089                        
    1090                         Q[Qoff + 1] = q1;
    1091                         Q[Qoff + 17] = q17;
    1092                         Q[Qoff + 18] = q18;
    1093                         Q[Qoff + 19] = q19;
    1094                         Q[Qoff + 20] = q20;
    1095 
    1096                         block[0] = m0;
    1097                         block[1] = m1;
    1098 
    1099                         MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    1100                         UInt32 q21 = GG(Q[Qoff+20], Q[Qoff+19], Q[Qoff+18]) + Q[Qoff+17] + 0xd62f105d + block[5];
    1101                         q21 = RL(q21, 5); q21 += Q[Qoff+20];
    1102                         if (0 != ((q21^Q[Qoff+20]) & 0x80020000)) continue;
    1103                         Q[Qoff+21] = q21;
    1104 
    1105                         counter = 0;
    1106                         break;
    1107                 }
    1108                 if (counter != 0)
    1109                         continue;
    1110 
    1111                  UInt32 q9b = Q[Qoff + 9];
    1112                  UInt32 q10b = Q[Qoff + 10];
    1113        
    1114                 MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
    1115                 MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
    1116                 MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
    1117                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    1118 
    1119                  UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
    1120                  UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
    1121                  UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
    1122                  UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
    1123          
    1124                 for (UInt32 k10 = 0; k10 < (1<<4); ++k10)
    1125                 {
    1126                         UInt32 q10 = q10b | (q9q10mask[k10]&0x08000004);
    1127                         UInt32 m10 = RR(Q[Qoff+11]-q10,17);
    1128                         UInt32 q9 = q9b | (q9q10mask[k10]&0x00004200);
    1129 
    1130                         m10 -= FF(q10, q9, Q[Qoff+8]) + tt10;
    1131 
    1132                         UInt32 aa = Q[Qoff + 21];
    1133                         UInt32 dd = tt22+m10; dd = RL(dd, 9) + aa;
    1134                         if (0 != (dd & 0x80000000)) continue;                   
    1135 
    1136                         UInt32 bb = Q[Qoff + 20];
    1137                         UInt32 cc = tt23 + GG(dd, aa, bb);
    1138                         if (0 != (cc & 0x20000)) continue;
    1139                         cc = RL(cc, 14) + dd;
    1140                         if (0 != (cc & 0x80000000)) continue;
    1141 
    1142                         bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    1143                         if (0 == (bb & 0x80000000)) continue;
    1144 
    1145                         block[10] = m10;
    1146                         Q[Qoff + 9] = q9;
    1147                         Q[Qoff + 10] = q10;
    1148                         MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
    1149 
    1150                         for (UInt32 k9 = 0; k9 < (1<<10); ++k9)
    1151                         {
    1152                                 UInt32 a = aa, b = bb, c = cc, d = dd;
    1153                                 Q[Qoff + 9] = q9 ^ q9mask[k9];
    1154                                 MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
    1155                                 MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
    1156                                 MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    1157 
    1158                                 MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    1159                                 MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    1160                                 MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    1161                                 MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    1162                                 MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    1163                                 MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    1164                                 MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    1165                                 MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    1166                                 MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    1167                                 MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
    1168 
    1169                                 c += HH(d, a, b) + block[11] + 0x6d9d6122;
    1170                                 if (0 != (c & (1 << 15)))
    1171                                         continue;
    1172                                 c = (c<<16 | c>>16) + d;
    1173                                        
    1174                                 MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    1175                                 MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    1176                                 MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    1177                                 MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    1178                                 MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    1179                                 MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    1180                                 MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    1181                                 MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    1182                                 MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    1183                                 MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    1184                                 MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    1185                                 MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    1186                                 MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    1187                                 if (0 != ((b^d) & 0x80000000))
    1188                                         continue;
    1189 
    1190                                 MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1191                                 if (0 != ((a^c) >> 31)) continue;
    1192                                 MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1193                                 if (0 == ((b^d) >> 31)) continue;
    1194                                 MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1195                                 if (0 != ((a^c) >> 31)) continue;
    1196                                 MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1197                                 if (0 != ((b^d) >> 31)) continue;
    1198                                 MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1199                                 if (0 != ((a^c) >> 31)) continue;
    1200                                 MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1201                                 if (0 != ((b^d) >> 31)) continue;
    1202                                 MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1203                                 if (0 != ((a^c) >> 31)) continue;
    1204                                 MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1205                                 if (0 != ((b^d) >> 31)) continue;
    1206                                 MD5_STEP(II,ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
    1207                                 if (0 != ((a^c) >> 31)) continue;
    1208                                 MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1209                                 if (0 != ((b^d) >> 31)) continue;
    1210                                 MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    1211                                 if (0 != ((a^c) >> 31)) continue;
    1212                                 MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    1213                                 if (0 == ((b^d) >> 31)) continue;
    1214                                 MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    1215                                 if (0 != ((a^c) >> 31)) continue;
    1216                                 MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    1217                                 if (0 != ((b^d) >> 31)) continue;
    1218                                 MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1219                                 if (0 != ((a^c) >> 31)) continue;
    1220                                 MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    1221 
    1222                                 //std::cout << "." << std::flush;
    1223 
    1224                                 UInt32[] block2= new UInt32[16];
    1225                                 UInt32[] IV1= new UInt32[4], IV2= new UInt32[4];
    1226                                 for (int t = 0; t < 4; ++t)
    1227                                 {
    1228                                         IV1[t] = IV[t];
    1229                                         IV2[t] = IV[t] + ((UInt32)1 << 31);
    1230                                 }
    1231                                 IV2[1] -= (1 << 25);
    1232                                 IV2[2] -= (1 << 25);
    1233                                 IV2[3] -= (1 << 25);
    1234 
    1235                                 for (int t = 0; t < 16; ++t)
    1236                                         block2[t] = block[t];
    1237                                 block2[4] += (UInt32)1<<31;
    1238                                 block2[11] += 1<<15;
    1239                                 block2[14] += (UInt32)1<<31;
    1240 
    1241                                 md5_compress(IV1, block);
    1242                                 md5_compress(IV2, block2);
    1243                                 if (IV2[0]==IV1[0] && IV2[1]==IV1[1] && IV2[2]==IV1[2] && IV2[3]==IV1[3])
    1244                                         return;
    1245 
    1246                                 //if (IV2[0] != IV1[0])
    1247                                 //              std::cout << "!" << std::flush;
    1248                         }
    1249                 }
    1250         }
    1251 }
     1060        {
     1061            UInt32[] Q = new UInt32[68];
     1062            Q[0] = IV[0];
     1063            Q[1] = IV[3];
     1064            Q[2] = IV[2];
     1065            Q[3] = IV[1];
     1066
     1067            UInt32[] q9q10mask = new UInt32[1 << 4];
     1068            for (UInt32 k = 0; k < q9q10mask.Length; ++k)
     1069                q9q10mask[k] = ((k << 2) ^ (k << 8) ^ (k << 11) ^ (k << 25)) & 0x08004204;
     1070
     1071            UInt32[] q9mask = new UInt32[1 << 10];
     1072            for (UInt32 k = 0; k < q9mask.Length; ++k)
     1073                q9mask[k] = ((k << 1) ^ (k << 2) ^ (k << 3) ^ (k << 7) ^ (k << 12) ^ (k << 15) ^ (k << 18) ^ (k << 20)) & 0x2471042a;
     1074
     1075            while (true)
     1076            {
     1077                if (IsStopped)
     1078                    return;
     1079
     1080                UInt32 aa1 = Q[Qoff] & 0x80000000;
     1081
     1082                Q[Qoff + 2] = (xrng64() & 0x79b0c6ba) | 0x024c3841 | aa1;
     1083                Q[Qoff + 3] = (xrng64() & 0x19300210) | 0x2603096d | (Q[Qoff + 2] & 0x80000082);
     1084                Q[Qoff + 4] = (xrng64() & 0x10300000) | 0xe4cae30c | (Q[Qoff + 3] & 0x01000030);
     1085                Q[Qoff + 5] = (xrng64() & 0x10000000) | 0x63494061 | (Q[Qoff + 4] & 0x00300000);
     1086                Q[Qoff + 6] = 0x7deaff68;
     1087                Q[Qoff + 7] = (xrng64() & 0x20444000) | 0x09091ee0;
     1088                Q[Qoff + 8] = (xrng64() & 0x09040000) | 0xb2529f6d;
     1089                Q[Qoff + 9] = (xrng64() & 0x00040000) | 0x10885184;
     1090                Q[Qoff + 10] = (xrng64() & 0x00000080) | 0x428afb11 | (Q[Qoff + 9] & 0x00040000);
     1091                Q[Qoff + 11] = (xrng64() & 0x128a8110) | 0x6571266b | (Q[Qoff + 10] & 0x0000080);
     1092                Q[Qoff + 12] = (xrng64() & 0x3ef38d7f) | 0x00003080 | (~Q[Qoff + 11] & 0x00080000);
     1093                Q[Qoff + 13] = (xrng64() & 0x3efb1d77) | 0x0004c008;
     1094                Q[Qoff + 14] = (xrng64() & 0x5fff5d77) | 0x8000a288;
     1095                Q[Qoff + 15] = (xrng64() & 0x1efe7ff7) | 0xe0008000 | (~Q[Qoff + 14] & 0x00010000);
     1096                Q[Qoff + 16] = (xrng64() & 0x5ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x00020000);
     1097
     1098                MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     1099                MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
     1100                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     1101                MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
     1102                MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
     1103                MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
     1104
     1105                UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
     1106                UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
     1107                UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
     1108
     1109                UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
     1110                UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;
     1111
     1112                UInt32 q1a = 0x02000941 ^ (Q[Qoff + 0] & 0x80000000);
     1113
     1114                UInt32 counter = 0;
     1115                while (counter < (1 << 12))
     1116                {
     1117                    if (IsStopped)
     1118                        return;
     1119
     1120                    ++counter;
     1121
     1122                    UInt32 q1 = q1a | (xrng64() & 0x7dfdf6be);
     1123                    UInt32 m1 = Q[Qoff + 2] - q1;
     1124                    m1 = RR(m1, 12) - FF(q1, Q[Qoff + 0], Q[Qoff - 1]) - tt1;
     1125
     1126                    UInt32 q16 = Q[Qoff + 16];
     1127                    UInt32 q17 = tt17 + m1;
     1128                    q17 = RL(q17, 5) + q16;
     1129                    if (0x80000000 != ((q17 ^ q16) & 0x80008008)) continue;
     1130                    if (0 != (q17 & 0x00020000)) continue;
     1131
     1132                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
     1133                    q18 = RL(q18, 9); q18 += q17;
     1134                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     1135
     1136                    UInt32 q19 = GG(q18, q17, q16) + tt19;
     1137                    q19 = RL(q19, 14); q19 += q18;
     1138                    if (0 != (q19 & 0x80020000)) continue;
     1139
     1140                    UInt32 m0 = q1 - Q[Qoff + 0];
     1141                    m0 = RR(m0, 7) - tt0;
     1142
     1143                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
     1144                    q20 = RL(q20, 20); q20 += q19;
     1145                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     1146
     1147                    Q[Qoff + 1] = q1;
     1148                    Q[Qoff + 17] = q17;
     1149                    Q[Qoff + 18] = q18;
     1150                    Q[Qoff + 19] = q19;
     1151                    Q[Qoff + 20] = q20;
     1152
     1153                    block[0] = m0;
     1154                    block[1] = m1;
     1155
     1156                    MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     1157                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
     1158                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
     1159                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     1160                    Q[Qoff + 21] = q21;
     1161
     1162                    counter = 0;
     1163                    break;
     1164                }
     1165                if (counter != 0)
     1166                    continue;
     1167
     1168                UInt32 q9b = Q[Qoff + 9];
     1169                UInt32 q10b = Q[Qoff + 10];
     1170
     1171                MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
     1172                MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
     1173                MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
     1174                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     1175
     1176                UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
     1177                UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
     1178                UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
     1179                UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
     1180
     1181                for (UInt32 k10 = 0; k10 < (1 << 4); ++k10)
     1182                {
     1183                    if (IsStopped)
     1184                        return;
     1185
     1186                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000004);
     1187                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     1188                    UInt32 q9 = q9b | (q9q10mask[k10] & 0x00004200);
     1189
     1190                    m10 -= FF(q10, q9, Q[Qoff + 8]) + tt10;
     1191
     1192                    UInt32 aa = Q[Qoff + 21];
     1193                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
     1194                    if (0 != (dd & 0x80000000)) continue;
     1195
     1196                    UInt32 bb = Q[Qoff + 20];
     1197                    UInt32 cc = tt23 + GG(dd, aa, bb);
     1198                    if (0 != (cc & 0x20000)) continue;
     1199                    cc = RL(cc, 14) + dd;
     1200                    if (0 != (cc & 0x80000000)) continue;
     1201
     1202                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
     1203                    if (0 == (bb & 0x80000000)) continue;
     1204
     1205                    block[10] = m10;
     1206                    Q[Qoff + 9] = q9;
     1207                    Q[Qoff + 10] = q10;
     1208                    MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
     1209
     1210                    for (UInt32 k9 = 0; k9 < (1 << 10); ++k9)
     1211                    {
     1212                        if (IsStopped)
     1213                            return;
     1214
     1215                        UInt32 a = aa, b = bb, c = cc, d = dd;
     1216                        Q[Qoff + 9] = q9 ^ q9mask[k9];
     1217                        MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
     1218                        MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
     1219                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
     1220
     1221                        MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
     1222                        MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
     1223                        MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
     1224                        MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
     1225                        MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
     1226                        MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     1227                        MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
     1228                        MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     1229                        MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
     1230                        MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     1231
     1232                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     1233                        if (0 != (c & (1 << 15)))
     1234                            continue;
     1235                        c = (c << 16 | c >> 16) + d;
     1236
     1237                        MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
     1238                        MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
     1239                        MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     1240                        MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     1241                        MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
     1242                        MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
     1243                        MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
     1244                        MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
     1245                        MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
     1246                        MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
     1247                        MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
     1248                        MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     1249                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     1250                        if (0 != ((b ^ d) & 0x80000000))
     1251                            continue;
     1252
     1253                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     1254                        if (0 != ((a ^ c) >> 31)) continue;
     1255                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1256                        if (0 == ((b ^ d) >> 31)) continue;
     1257                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1258                        if (0 != ((a ^ c) >> 31)) continue;
     1259                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1260                        if (0 != ((b ^ d) >> 31)) continue;
     1261                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1262                        if (0 != ((a ^ c) >> 31)) continue;
     1263                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1264                        if (0 != ((b ^ d) >> 31)) continue;
     1265                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1266                        if (0 != ((a ^ c) >> 31)) continue;
     1267                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1268                        if (0 != ((b ^ d) >> 31)) continue;
     1269                        MD5_STEP(II, ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
     1270                        if (0 != ((a ^ c) >> 31)) continue;
     1271                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1272                        if (0 != ((b ^ d) >> 31)) continue;
     1273                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1274                        if (0 != ((a ^ c) >> 31)) continue;
     1275                        MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
     1276                        if (0 == ((b ^ d) >> 31)) continue;
     1277                        MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     1278                        if (0 != ((a ^ c) >> 31)) continue;
     1279                        MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     1280                        if (0 != ((b ^ d) >> 31)) continue;
     1281                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1282                        if (0 != ((a ^ c) >> 31)) continue;
     1283                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1284
     1285                        //std::cout << "." << std::flush;
     1286
     1287                        UInt32[] block2 = new UInt32[16];
     1288                        UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
     1289                        for (int t = 0; t < 4; ++t)
     1290                        {
     1291                            IV1[t] = IV[t];
     1292                            IV2[t] = IV[t] + ((UInt32)1 << 31);
     1293                        }
     1294                        IV2[1] -= (1 << 25);
     1295                        IV2[2] -= (1 << 25);
     1296                        IV2[3] -= (1 << 25);
     1297
     1298                        for (int t = 0; t < 16; ++t)
     1299                            block2[t] = block[t];
     1300                        block2[4] += (UInt32)1 << 31;
     1301                        block2[11] += 1 << 15;
     1302                        block2[14] += (UInt32)1 << 31;
     1303
     1304                        md5_compress(IV1, block);
     1305                        md5_compress(IV2, block2);
     1306                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1307                            return;
     1308
     1309                        //if (IV2[0] != IV1[0])
     1310                        //              std::cout << "!" << std::flush;
     1311                    }
     1312                }
     1313            }
     1314        }
    12521315
    12531316
    12541317        void find_block1_stevens_11(UInt32[] block, UInt32[] IV)
    1255 {
    1256         UInt32[] Q = new UInt32[68];
    1257         Q[0] = IV[0];
    1258         Q[1] = IV[3];
    1259         Q[2] = IV[2];
    1260         Q[3] = IV[1];
    1261 
    1262         UInt32[] q9q10mask= new UInt32[1<<5];
    1263         for (UInt32 k = 0; k < q9q10mask.Length; ++k)
    1264                 q9q10mask[k] = ((k<<5) ^ (k<<6) ^ (k<<7) ^ (k<<24) ^ (k<<27)) & 0x880002a0;
    1265        
    1266         UInt32[] q9mask= new UInt32[1<<9];
    1267         for (UInt32 k = 0; k < q9mask.Length; ++k)
    1268                 q9mask[k] = ((k<<1) ^ (k<<3) ^ (k<<8) ^ (k<<12) ^ (k<<15) ^ (k<<18)) & 0x04710c12;
    1269        
    1270         while (true)
    1271         {
    1272                 UInt32 aa1 = Q[Qoff] & 0x80000000;
    1273 
    1274                 Q[Qoff + 2] = (xrng64() & 0x75bef63e) | 0x0a410041 | aa1;
    1275                 Q[Qoff + 3] = (xrng64() & 0x10345614) | 0x0202a9e1 | (Q[Qoff + 2] & 0x84000002);
    1276                 Q[Qoff + 4] = (xrng64() & 0x00145400) | 0xe84ba909 | (Q[Qoff + 3] & 0x00000014);
    1277                 Q[Qoff + 5] = (xrng64() & 0x80000000) | 0x75e90b1d | (Q[Qoff + 4] & 0x00145400);
    1278                 Q[Qoff + 6] = 0x7c23ff5a | (Q[Qoff + 5] & 0x80000000);
    1279                 Q[Qoff + 7] = (xrng64() & 0x40000880) | 0x114bf41a;
    1280                 Q[Qoff + 8] = (xrng64() & 0x00002090) | 0xb352dd01;
    1281                 Q[Qoff + 9] = (xrng64() & 0x00044000) | 0x7a803124;
    1282                 Q[Qoff +10] = (xrng64() & 0x00002000) | 0xf28a92c9 | (Q[Qoff + 9] & 0x00044000);
    1283                 Q[Qoff +11] = (xrng64() & 0x128a8108) | 0xc5710ed7 | (Q[Qoff + 10] & 0x00002000);
    1284                 Q[Qoff +12] = (xrng64() & 0x9edb8d7f) | 0x20003080 | (~Q[Qoff + 11] & 0x00200000);
    1285                 Q[Qoff +13] = (xrng64() & 0x3efb1d77) | 0x4004c008 | (Q[Qoff + 12] & 0x80000000);
    1286                 Q[Qoff +14] = (xrng64() & 0x1fff5d77) | 0x0000a288;
    1287                 Q[Qoff +15] = (xrng64() & 0x1efe7ff7) | 0x20008000 | (~Q[Qoff + 14] & 0x00010000);
    1288                 Q[Qoff +16] = (xrng64() & 0x1ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x40020000);
    1289                
    1290                 MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    1291                 MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
    1292                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    1293                 MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
    1294                 MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
    1295                 MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
    1296 
    1297                  UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
    1298                  UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
    1299                  UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
    1300 
    1301                  UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
    1302                  UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;         
    1303 
    1304                  UInt32 q1a = 0x02000861 ^ (Q[Qoff + 0] & 0x80000020);
    1305                
    1306                 UInt32 counter = 0;
    1307                 while (counter < (1 << 12))
    1308                 {
    1309                         ++counter;
    1310 
    1311                         UInt32 q1 = q1a | (xrng64() & 0x7dfff79e);
    1312                         UInt32 m1 = Q[Qoff+2] - q1;
    1313                         m1 = RR(m1, 12) - FF(q1, Q[Qoff+0], Q[Qoff-1]) - tt1;
    1314 
    1315                          UInt32 q16 = Q[Qoff+16];
    1316                         UInt32 q17 = tt17 + m1;
    1317                         q17 = RL(q17, 5) + q16;
    1318                         if (0x40000000 != ((q17^q16) & 0xc0008008)) continue;
    1319                         if (0 != (q17 & 0x00020000)) continue;
    1320 
    1321                         UInt32 q18 = GG(q17, q16, Q[Qoff+15]) + tt18;
    1322                         q18 = RL(q18, 9); q18 += q17;
    1323                         if (0x80020000 != ((q18^q17) & 0xa0020000)) continue;
    1324 
    1325                         UInt32 q19 = GG(q18, q17, q16) + tt19;
    1326                         q19 = RL(q19, 14); q19 += q18;
    1327                         if (0x80000000 != (q19 & 0x80020000)) continue;
    1328 
    1329                         UInt32 m0 = q1 - Q[Qoff + 0];
    1330                         m0 = RR(m0, 7) - tt0;
    1331 
    1332                         UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    1333                         q20 = RL(q20, 20); q20 += q19;
    1334                         if (0x00040000 != ((q20^q19) & 0x80040000))     continue;
    1335                        
    1336                         Q[Qoff + 1] = q1;
    1337                         Q[Qoff + 17] = q17;
    1338                         Q[Qoff + 18] = q18;
    1339                         Q[Qoff + 19] = q19;
    1340                         Q[Qoff + 20] = q20;
    1341 
    1342                         block[0] = m0;
    1343                         block[1] = m1;
    1344 
    1345                         MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    1346                         UInt32 q21 = GG(Q[Qoff+20], Q[Qoff+19], Q[Qoff+18]) + Q[Qoff+17] + 0xd62f105d + block[5];
    1347                         q21 = RL(q21, 5); q21 += Q[Qoff+20];
    1348                         if (0 != ((q21^Q[Qoff+20]) & 0x80020000)) continue;
    1349 
    1350                         Q[Qoff+21] = q21;
    1351 
    1352                         counter = 0;
    1353                         break;
    1354                 }
    1355                 if (counter != 0)
    1356                         continue;
    1357 
    1358                  UInt32 q9b = Q[Qoff + 9];
    1359                  UInt32 q10b = Q[Qoff + 10];
    1360 
    1361                 MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
    1362                 MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
    1363                 MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
    1364                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    1365 
    1366                  UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
    1367                  UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
    1368                  UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
    1369                  UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
    1370          
    1371                 for (UInt32 k10 = 0; k10 < (1<<5); ++k10)
    1372                 {
    1373                         UInt32 q10 = q10b | (q9q10mask[k10]&0x08000040);
    1374                         UInt32 m10 = RR(Q[Qoff+11]-q10,17);
    1375                         UInt32 q9 = q9b | (q9q10mask[k10]&0x80000280);
    1376 
    1377                         m10 -= FF(q10, q9, Q[Qoff+8]) + tt10;
    1378 
    1379                         UInt32 aa = Q[Qoff + 21];
    1380                         UInt32 dd = tt22+m10; dd = RL(dd, 9) + aa;
    1381                         if (0 == (dd & 0x80000000)) continue;                   
    1382 
    1383                         UInt32 bb = Q[Qoff + 20];
    1384                         UInt32 cc = tt23 + GG(dd, aa, bb);
    1385                         if (0 != (cc & 0x20000)) continue;
    1386                         cc = RL(cc, 14) + dd;
    1387                         if (0 != (cc & 0x80000000)) continue;
    1388 
    1389                         bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    1390                         if (0 == (bb & 0x80000000)) continue;
    1391 
    1392                         block[10] = m10;
    1393                         Q[Qoff + 9] = q9;
    1394                         Q[Qoff + 10] = q10;
    1395                         MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
    1396 
    1397                         for (UInt32 k9 = 0; k9 < (1<<9); ++k9)
    1398                         {
    1399                                 UInt32 a = aa, b = bb, c = cc, d = dd;
    1400                                 Q[Qoff + 9] = q9 ^ q9mask[k9];
    1401                                 MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
    1402                                 MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
    1403                                 MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    1404 
    1405                                 MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
    1406                                 MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    1407                                 MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    1408                                 MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    1409                                 MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    1410                                 MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    1411                                 MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    1412                                 MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    1413                                 MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    1414                                 MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
    1415 
    1416                                 c += HH(d, a, b) + block[11] + 0x6d9d6122;
    1417                                 if (0 != (c & (1 << 15)))
    1418                                         continue;
    1419                                 c = (c<<16 | c>>16) + d;
    1420                                        
    1421                                 MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    1422                                 MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    1423                                 MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    1424                                 MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    1425                                 MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    1426                                 MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    1427                                 MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    1428                                 MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    1429                                 MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    1430                                 MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    1431                                 MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    1432                                 MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    1433                                 MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    1434                                 if (0 != ((b^d) & 0x80000000))
    1435                                         continue;
    1436 
    1437                                 MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1438                                 if (0 != ((a^c) >> 31)) continue;
    1439                                 MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1440                                 if (0 == ((b^d) >> 31)) continue;
    1441                                 MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1442                                 if (0 != ((a^c) >> 31)) continue;
    1443                                 MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1444                                 if (0 != ((b^d) >> 31)) continue;
    1445                                 MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1446                                 if (0 != ((a^c) >> 31)) continue;
    1447                                 MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1448                                 if (0 != ((b^d) >> 31)) continue;
    1449                                 MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1450                                 if (0 != ((a^c) >> 31)) continue;
    1451                                 MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1452                                 if (0 != ((b^d) >> 31)) continue;
    1453                                 MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    1454                                 if (0 != ((a^c) >> 31)) continue;
    1455                                 MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1456                                 if (0 != ((b^d) >> 31)) continue;
    1457                                 MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    1458                                 if (0 != ((a^c) >> 31)) continue;
    1459                                 MD5_STEP(II,ref  b, c, d, a, block[13], 0x4e0811a1, 21);
    1460                                 if (0 == ((b^d) >> 31)) continue;
    1461                                 MD5_STEP(II,ref  a, b, c, d, block[4], 0xf7537e82, 6);
    1462                                 if (0 != ((a^c) >> 31)) continue;
    1463                                 MD5_STEP(II,ref  d, a, b, c, block[11], 0xbd3af235, 10);
    1464                                 if (0 != ((b^d) >> 31)) continue;
    1465                                 MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1466                                 if (0 != ((a^c) >> 31)) continue;
    1467                                 MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    1468 
    1469                                 //std::cout << "." << std::flush;
    1470 
    1471                                 UInt32[] block2 = new UInt32[16];
    1472                                 UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
    1473                                 for (int t = 0; t < 4; ++t)
    1474                                 {
    1475                                         IV1[t] = IV[t];
    1476                                         IV2[t] = IV[t] + ((UInt32)1 << 31);
    1477                                 }
    1478                                 IV2[1] -= (1 << 25);
    1479                                 IV2[2] -= (1 << 25);
    1480                                 IV2[3] -= (1 << 25);
    1481 
    1482                                 for (int t = 0; t < 16; ++t)
    1483                                         block2[t] = block[t];
    1484                                 block2[4] += (UInt32)1<<31;
    1485                                 block2[11] += 1<<15;
    1486                                 block2[14] += (UInt32)1<<31;
    1487 
    1488                                 md5_compress(IV1, block);
    1489                                 md5_compress(IV2, block2);
    1490                                 if (IV2[0]==IV1[0] && IV2[1]==IV1[1] && IV2[2]==IV1[2] && IV2[3]==IV1[3])
    1491                                         return;
    1492 
    1493                                 //if (IV2[0] != IV1[0])
    1494                                 //              std::cout << "!" << std::flush;
    1495                         }
    1496                 }
    1497         }
    1498 }
     1318        {
     1319            UInt32[] Q = new UInt32[68];
     1320            Q[0] = IV[0];
     1321            Q[1] = IV[3];
     1322            Q[2] = IV[2];
     1323            Q[3] = IV[1];
     1324
     1325            UInt32[] q9q10mask = new UInt32[1 << 5];
     1326            for (UInt32 k = 0; k < q9q10mask.Length; ++k)
     1327                q9q10mask[k] = ((k << 5) ^ (k << 6) ^ (k << 7) ^ (k << 24) ^ (k << 27)) & 0x880002a0;
     1328
     1329            UInt32[] q9mask = new UInt32[1 << 9];
     1330            for (UInt32 k = 0; k < q9mask.Length; ++k)
     1331                q9mask[k] = ((k << 1) ^ (k << 3) ^ (k << 8) ^ (k << 12) ^ (k << 15) ^ (k << 18)) & 0x04710c12;
     1332
     1333            while (true)
     1334            {
     1335                if (IsStopped)
     1336                    return;
     1337
     1338                UInt32 aa1 = Q[Qoff] & 0x80000000;
     1339
     1340                Q[Qoff + 2] = (xrng64() & 0x75bef63e) | 0x0a410041 | aa1;
     1341                Q[Qoff + 3] = (xrng64() & 0x10345614) | 0x0202a9e1 | (Q[Qoff + 2] & 0x84000002);
     1342                Q[Qoff + 4] = (xrng64() & 0x00145400) | 0xe84ba909 | (Q[Qoff + 3] & 0x00000014);
     1343                Q[Qoff + 5] = (xrng64() & 0x80000000) | 0x75e90b1d | (Q[Qoff + 4] & 0x00145400);
     1344                Q[Qoff + 6] = 0x7c23ff5a | (Q[Qoff + 5] & 0x80000000);
     1345                Q[Qoff + 7] = (xrng64() & 0x40000880) | 0x114bf41a;
     1346                Q[Qoff + 8] = (xrng64() & 0x00002090) | 0xb352dd01;
     1347                Q[Qoff + 9] = (xrng64() & 0x00044000) | 0x7a803124;
     1348                Q[Qoff + 10] = (xrng64() & 0x00002000) | 0xf28a92c9 | (Q[Qoff + 9] & 0x00044000);
     1349                Q[Qoff + 11] = (xrng64() & 0x128a8108) | 0xc5710ed7 | (Q[Qoff + 10] & 0x00002000);
     1350                Q[Qoff + 12] = (xrng64() & 0x9edb8d7f) | 0x20003080 | (~Q[Qoff + 11] & 0x00200000);
     1351                Q[Qoff + 13] = (xrng64() & 0x3efb1d77) | 0x4004c008 | (Q[Qoff + 12] & 0x80000000);
     1352                Q[Qoff + 14] = (xrng64() & 0x1fff5d77) | 0x0000a288;
     1353                Q[Qoff + 15] = (xrng64() & 0x1efe7ff7) | 0x20008000 | (~Q[Qoff + 14] & 0x00010000);
     1354                Q[Qoff + 16] = (xrng64() & 0x1ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x40020000);
     1355
     1356                MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     1357                MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
     1358                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     1359                MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
     1360                MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
     1361                MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
     1362
     1363                UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
     1364                UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
     1365                UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
     1366
     1367                UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
     1368                UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;
     1369
     1370                UInt32 q1a = 0x02000861 ^ (Q[Qoff + 0] & 0x80000020);
     1371
     1372                UInt32 counter = 0;
     1373                while (counter < (1 << 12))
     1374                {
     1375                    if (IsStopped)
     1376                        return;
     1377
     1378                    ++counter;
     1379
     1380                    UInt32 q1 = q1a | (xrng64() & 0x7dfff79e);
     1381                    UInt32 m1 = Q[Qoff + 2] - q1;
     1382                    m1 = RR(m1, 12) - FF(q1, Q[Qoff + 0], Q[Qoff - 1]) - tt1;
     1383
     1384                    UInt32 q16 = Q[Qoff + 16];
     1385                    UInt32 q17 = tt17 + m1;
     1386                    q17 = RL(q17, 5) + q16;
     1387                    if (0x40000000 != ((q17 ^ q16) & 0xc0008008)) continue;
     1388                    if (0 != (q17 & 0x00020000)) continue;
     1389
     1390                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
     1391                    q18 = RL(q18, 9); q18 += q17;
     1392                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     1393
     1394                    UInt32 q19 = GG(q18, q17, q16) + tt19;
     1395                    q19 = RL(q19, 14); q19 += q18;
     1396                    if (0x80000000 != (q19 & 0x80020000)) continue;
     1397
     1398                    UInt32 m0 = q1 - Q[Qoff + 0];
     1399                    m0 = RR(m0, 7) - tt0;
     1400
     1401                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
     1402                    q20 = RL(q20, 20); q20 += q19;
     1403                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     1404
     1405                    Q[Qoff + 1] = q1;
     1406                    Q[Qoff + 17] = q17;
     1407                    Q[Qoff + 18] = q18;
     1408                    Q[Qoff + 19] = q19;
     1409                    Q[Qoff + 20] = q20;
     1410
     1411                    block[0] = m0;
     1412                    block[1] = m1;
     1413
     1414                    MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     1415                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
     1416                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
     1417                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     1418
     1419                    Q[Qoff + 21] = q21;
     1420
     1421                    counter = 0;
     1422                    break;
     1423                }
     1424                if (counter != 0)
     1425                    continue;
     1426
     1427                UInt32 q9b = Q[Qoff + 9];
     1428                UInt32 q10b = Q[Qoff + 10];
     1429
     1430                MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
     1431                MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
     1432                MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
     1433                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     1434
     1435                UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
     1436                UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
     1437                UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
     1438                UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
     1439
     1440                for (UInt32 k10 = 0; k10 < (1 << 5); ++k10)
     1441                {
     1442                    if (IsStopped)
     1443                        return;
     1444
     1445                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000040);
     1446                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     1447                    UInt32 q9 = q9b | (q9q10mask[k10] & 0x80000280);
     1448
     1449                    m10 -= FF(q10, q9, Q[Qoff + 8]) + tt10;
     1450
     1451                    UInt32 aa = Q[Qoff + 21];
     1452                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
     1453                    if (0 == (dd & 0x80000000)) continue;
     1454
     1455                    UInt32 bb = Q[Qoff + 20];
     1456                    UInt32 cc = tt23 + GG(dd, aa, bb);
     1457                    if (0 != (cc & 0x20000)) continue;
     1458                    cc = RL(cc, 14) + dd;
     1459                    if (0 != (cc & 0x80000000)) continue;
     1460
     1461                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
     1462                    if (0 == (bb & 0x80000000)) continue;
     1463
     1464                    block[10] = m10;
     1465                    Q[Qoff + 9] = q9;
     1466                    Q[Qoff + 10] = q10;
     1467                    MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
     1468
     1469                    for (UInt32 k9 = 0; k9 < (1 << 9); ++k9)
     1470                    {
     1471                        if (IsStopped)
     1472                            return;
     1473
     1474                        UInt32 a = aa, b = bb, c = cc, d = dd;
     1475                        Q[Qoff + 9] = q9 ^ q9mask[k9];
     1476                        MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
     1477                        MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
     1478                        MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
     1479
     1480                        MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
     1481                        MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
     1482                        MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
     1483                        MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
     1484                        MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
     1485                        MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     1486                        MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
     1487                        MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     1488                        MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
     1489                        MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     1490
     1491                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
     1492                        if (0 != (c & (1 << 15)))
     1493                            continue;
     1494                        c = (c << 16 | c >> 16) + d;
     1495
     1496                        MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
     1497                        MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
     1498                        MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     1499                        MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     1500                        MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
     1501                        MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
     1502                        MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
     1503                        MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
     1504                        MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
     1505                        MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
     1506                        MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
     1507                        MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     1508                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     1509                        if (0 != ((b ^ d) & 0x80000000))
     1510                            continue;
     1511
     1512                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     1513                        if (0 != ((a ^ c) >> 31)) continue;
     1514                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1515                        if (0 == ((b ^ d) >> 31)) continue;
     1516                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1517                        if (0 != ((a ^ c) >> 31)) continue;
     1518                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1519                        if (0 != ((b ^ d) >> 31)) continue;
     1520                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1521                        if (0 != ((a ^ c) >> 31)) continue;
     1522                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1523                        if (0 != ((b ^ d) >> 31)) continue;
     1524                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1525                        if (0 != ((a ^ c) >> 31)) continue;
     1526                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1527                        if (0 != ((b ^ d) >> 31)) continue;
     1528                        MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     1529                        if (0 != ((a ^ c) >> 31)) continue;
     1530                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1531                        if (0 != ((b ^ d) >> 31)) continue;
     1532                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
     1533                        if (0 != ((a ^ c) >> 31)) continue;
     1534                        MD5_STEP(II, ref  b, c, d, a, block[13], 0x4e0811a1, 21);
     1535                        if (0 == ((b ^ d) >> 31)) continue;
     1536                        MD5_STEP(II, ref  a, b, c, d, block[4], 0xf7537e82, 6);
     1537                        if (0 != ((a ^ c) >> 31)) continue;
     1538                        MD5_STEP(II, ref  d, a, b, c, block[11], 0xbd3af235, 10);
     1539                        if (0 != ((b ^ d) >> 31)) continue;
     1540                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1541                        if (0 != ((a ^ c) >> 31)) continue;
     1542                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1543
     1544                        //std::cout << "." << std::flush;
     1545
     1546                        UInt32[] block2 = new UInt32[16];
     1547                        UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
     1548                        for (int t = 0; t < 4; ++t)
     1549                        {
     1550                            IV1[t] = IV[t];
     1551                            IV2[t] = IV[t] + ((UInt32)1 << 31);
     1552                        }
     1553                        IV2[1] -= (1 << 25);
     1554                        IV2[2] -= (1 << 25);
     1555                        IV2[3] -= (1 << 25);
     1556
     1557                        for (int t = 0; t < 16; ++t)
     1558                            block2[t] = block[t];
     1559                        block2[4] += (UInt32)1 << 31;
     1560                        block2[11] += 1 << 15;
     1561                        block2[14] += (UInt32)1 << 31;
     1562
     1563                        md5_compress(IV1, block);
     1564                        md5_compress(IV2, block2);
     1565                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1566                            return;
     1567
     1568                        //if (IV2[0] != IV1[0])
     1569                        //              std::cout << "!" << std::flush;
     1570                    }
     1571                }
     1572            }
     1573        }
    14991574
    15001575
    15011576        void find_block1_wang(UInt32[] block, UInt32[] IV)
    1502 {
    1503         UInt32[] Q = new UInt32[68];
    1504         Q[0] = IV[0];
    1505         Q[1] = IV[3];
    1506         Q[2] = IV[2];
    1507         Q[3] = IV[1];
    1508 
    1509         UInt32[] q4mask= new UInt32[1<<6];
    1510         for (UInt32 k = 0; k < q4mask.Length; ++k)
    1511                 q4mask[k] = ((k<<13) ^ (k<<19)) & 0x01c0e000;
    1512 
    1513         UInt32[] q9mask= new UInt32[1<<5], q10mask= new UInt32[1<<5];
    1514         for (UInt32 k = 0; k < q9mask.Length; ++k)
    1515         {
    1516                 UInt32 msk = (k<<5) ^ (k<<13) ^ (k<<17) ^ (k<<24);
    1517                 q9mask[k] = msk &  0x00084000;
    1518                 q10mask[k] = msk & 0x18000020;
    1519         }
    1520        
    1521         UInt32[] q9mask2= new UInt32[1<<10];
    1522         for (UInt32 k = 0; k < q9mask2.Length; ++k)
    1523                 q9mask2[k] = ((k<<1) ^ (k<<7) ^ (k<<14) ^ (k<<15) ^ (k<<22)) & 0x6074041c;
    1524        
    1525        
    1526         while (true)
    1527         {
    1528                 UInt32 aa1= Q[Qoff] & 0x80000000;
    1529                 UInt32 bb1 = 0x80000000 ^ aa1;
    1530 
    1531                 Q[Qoff + 2] = (xrng64() & 0x71de7799) | 0x0c008840 | bb1;
    1532                 Q[Qoff + 3] = (xrng64() & 0x01c06601) | 0x3e1f0966 | (Q[Qoff + 2] & 0x80000018);
    1533                 Q[Qoff + 4] = 0x3a040010 | (Q[Qoff + 3] & 0x80000601);
    1534                 Q[Qoff + 5] = (xrng64() & 0x03c0e000) | 0x482f0e50 | aa1;
    1535                 Q[Qoff + 6] = (xrng64() & 0x600c0000) | 0x05e2ec56 | aa1;
    1536                 Q[Qoff + 7] = (xrng64() & 0x604c203e) | 0x16819e01 | bb1 | (Q[Qoff + 6] & 0x01000000);
    1537                 Q[Qoff + 8] = (xrng64() & 0x604c7c1c) | 0x043283e0 | (Q[Qoff + 7] & 0x80000002);
    1538                 Q[Qoff + 9] =  (xrng64() & 0x00002800) | 0x1c0101c1 | (Q[Qoff + 8] & 0x80001000);
    1539                 Q[Qoff + 10] = 0x078bcbc0 | bb1;
    1540                 Q[Qoff + 11] = (xrng64() & 0x07800000) | 0x607dc7df | bb1;
    1541                 Q[Qoff + 12] = (xrng64() & 0x00f00f7f) | 0x00081080 | (Q[Qoff + 11] & 0xe7000000);
    1542                 Q[Qoff + 13] = (xrng64() & 0x00701f77) | 0x3f0fe008 | aa1;
    1543                 Q[Qoff + 14] = (xrng64() & 0x00701f77) | 0x408be088 | aa1;
    1544                 Q[Qoff + 15] = (xrng64() & 0x00ff3ff7) | 0x7d000000;
    1545                 Q[Qoff + 16] = (xrng64() & 0x4ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x00020000);
    1546            
    1547                 MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    1548                 MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
    1549                 MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    1550                 MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
    1551                 MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
    1552                 MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
    1553 
    1554                  UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
    1555                  UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
    1556                  UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
    1557 
    1558                  UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
    1559                  UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;         
    1560 
    1561                  UInt32 q1a = 0x04200040 | (Q[Qoff + 2] & 0xf01e1080);
    1562                
    1563                 UInt32 counter = 0;
    1564                 while (counter < (1 << 12))
    1565                 {
    1566                         ++counter;
    1567 
    1568                         UInt32 q1 = q1a | (xrng64() & 0x01c0e71f);
    1569                         UInt32 m1 = Q[Qoff+2] - q1;
    1570                         m1 = RR(m1, 12) - FF(q1, Q[Qoff+0], Q[Qoff-1]) - tt1;
    1571 
    1572                          UInt32 q16 = Q[Qoff+16];
    1573                         UInt32 q17 = tt17 + m1;
    1574                         q17 = RL(q17, 5) + q16;
    1575                         if (0x40000000 != ((q17^q16) & 0xc0008008)) continue;
    1576                         if (0 != (q17 & 0x00020000)) continue;
    1577 
    1578                         UInt32 q18 = GG(q17, q16, Q[Qoff+15]) + tt18;
    1579                         q18 = RL(q18, 9); q18 += q17;
    1580                         if (0x00020000 != ((q18^q17) & 0xa0020000)) continue;
    1581 
    1582                         UInt32 q19 = GG(q18, q17, q16) + tt19;
    1583                         q19 = RL(q19, 14); q19 += q18;
    1584                         if (0 != (q19 & 0x80020000)) continue;
    1585 
    1586                         UInt32 m0 = q1 - Q[Qoff + 0];
    1587                         m0 = RR(m0, 7) - tt0;
    1588 
    1589                         UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    1590                         q20 = RL(q20, 20); q20 += q19;
    1591                         if (0x00040000 != ((q20^q19) & 0x80040000))     continue;
    1592                        
    1593                         Q[Qoff + 1] = q1;
    1594                         Q[Qoff + 17] = q17;
    1595                         Q[Qoff + 18] = q18;
    1596                         Q[Qoff + 19] = q19;
    1597                         Q[Qoff + 20] = q20;
    1598 
    1599                         block[0] = m0;
    1600                         block[1] = m1;
    1601                         MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
    1602 
    1603                         counter = 0;
    1604                         break;
    1605                 }
    1606                 if (counter != 0)
    1607                         continue;
    1608 
    1609                  UInt32 q4b = Q[Qoff + 4];
    1610                  UInt32 q9b = Q[Qoff + 9];
    1611                  UInt32 q10b = Q[Qoff + 10];
    1612                  UInt32 tt21 = GG(Q[Qoff+20], Q[Qoff+19], Q[Qoff+18]) + Q[Qoff+17] + 0xd62f105d;
    1613 
    1614                 counter = 0;
    1615                 while (counter < (1<<6))
    1616                 {
    1617                         Q[Qoff + 4] = q4b ^ q4mask[counter];
    1618                         ++counter;
    1619                         MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
    1620                         UInt32 q21 = tt21 + block[5];
    1621                         q21 = RL(q21, 5); q21 += Q[Qoff+20];
    1622                         if (0 != ((q21^Q[Qoff+20]) & 0x80020000)) continue;
    1623 
    1624                         Q[Qoff+21] = q21;
    1625                         MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
    1626                         MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
    1627                         MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
    1628 
    1629                          UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
    1630                          UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
    1631                          UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
    1632                          UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
    1633          
    1634                         UInt32 counter2 = 0;
    1635                         while (counter2 < (1<<5))
    1636                         {
    1637                                 UInt32 q10 = q10b ^ q10mask[counter2];
    1638                                 UInt32 m10 = RR(Q[Qoff+11]-q10,17);
    1639                                 UInt32 q9 = q9b ^ q9mask[counter2];
    1640                                 ++counter2;
    1641 
    1642                                 m10 -= FF(q10, q9, Q[Qoff+8]) + tt10;
    1643 
    1644                                 UInt32 aa = Q[Qoff + 21];
    1645                                 UInt32 dd = tt22+m10; dd = RL(dd, 9) + aa;
    1646                                 if (0 != (dd & 0x80000000)) continue;                   
    1647 
    1648                                 UInt32 bb = Q[Qoff + 20];
    1649                                 UInt32 cc = tt23 + GG(dd, aa, bb);
    1650                                 if (0 != (cc & 0x20000)) continue;
    1651                                 cc = RL(cc, 14) + dd;
    1652                                 if (0 != (cc & 0x80000000)) continue;
    1653 
    1654                                 bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    1655                                 if (0 == (bb & 0x80000000)) continue;
    1656 
    1657                                 block[10] = m10;
    1658                                 Q[Qoff + 9] = q9;
    1659                                 Q[Qoff + 10] = q10;
    1660                                 MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
    1661 
    1662                                 for (UInt32 k9 = 0; k9 < (1<<10);)
    1663                                 {
    1664                                         UInt32 a = aa, b = bb, c = cc, d = dd;
    1665                                         Q[Qoff + 9] = q9 ^ q9mask2[k9]; ++k9;
    1666                                         MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
    1667                                         MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
    1668                                         MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
    1669 
    1670                                         MD5_STEP(GG,ref a, b, c, d, block[9], 0x21e1cde6, 5);
    1671                                         MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
    1672                                         MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
    1673                                         MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
    1674                                         MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
    1675                                         MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
    1676                                         MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
    1677                                         MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
    1678                                         MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
    1679                                         MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
    1680 
    1681                                         c += HH(d, a, b) + block[11] + 0x6d9d6122;
    1682                                         if (0 == (c & (1 << 15)))
    1683                                                 continue;
    1684                                         c = (c<<16 | c>>16) + d;
    1685                                        
    1686                                         MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
    1687                                         MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
    1688                                         MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
    1689                                         MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
    1690                                         MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
    1691                                         MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
    1692                                         MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
    1693                                         MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
    1694                                         MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
    1695                                         MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
    1696                                         MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
    1697                                         MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
    1698                                         MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    1699                                         if (0 != ((b^d) & 0x80000000))
    1700                                                 continue;
    1701 
    1702                                         MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1703                                         if (0 != ((a^c) >> 31)) continue;
    1704                                         MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1705                                         if (0 == ((b^d) >> 31)) continue;
    1706                                         MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1707                                         if (0 != ((a^c) >> 31)) continue;
    1708                                         MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1709                                         if (0 != ((b^d) >> 31)) continue;
    1710                                         MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1711                                         if (0 != ((a^c) >> 31)) continue;
    1712                                         MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1713                                         if (0 != ((b^d) >> 31)) continue;
    1714                                         MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1715                                         if (0 != ((a^c) >> 31)) continue;
    1716                                         MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1717                                         if (0 != ((b^d) >> 31)) continue;
    1718                                         MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    1719                                         if (0 != ((a^c) >> 31)) continue;
    1720                                         MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1721                                         if (0 != ((b^d) >> 31)) continue;
    1722                                         MD5_STEP(II,ref  c, d, a, b, block[6], 0xa3014314, 15);
    1723                                         if (0 != ((a^c) >> 31)) continue;
    1724                                         MD5_STEP(II,ref  b, c, d, a, block[13], 0x4e0811a1, 21);
    1725                                         if (0 == ((b^d) >> 31)) continue;
    1726                                         MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    1727                                         if (0 != ((a^c) >> 31)) continue;
    1728                                         MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    1729                                         if (0 != ((b^d) >> 31)) continue;
    1730                                         MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1731                                         if (0 != ((a^c) >> 31)) continue;
    1732                                         MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    1733 
    1734                                         //std::cout << "." << std::flush;
    1735 
    1736                                         UInt32[] block2 = new UInt32[16];
    1737                                         UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
    1738                                         for (int t = 0; t < 4; ++t)
    1739                                         {
    1740                                                 IV1[t] = IV[t];
    1741                                                 IV2[t] = IV[t] + ((UInt32)1 << 31);
    1742                                         }
    1743                                         IV2[1] += (1 << 25);
    1744                                         IV2[2] += (1 << 25);
    1745                                         IV2[3] += (1 << 25);
    1746 
    1747                                         for (int t = 0; t < 16; ++t)
    1748                                                 block2[t] = block[t];
    1749                                         block2[4] += (UInt32)1<<31;
    1750                                         block2[11] -= 1<<15;
    1751                                         block2[14] += (UInt32)1<<31;
    1752 
    1753                                         md5_compress(IV1, block);
    1754                                         md5_compress(IV2, block2);
    1755                                         if (IV2[0]==IV1[0] && IV2[1]==IV1[1] && IV2[2]==IV1[2] && IV2[3]==IV1[3])
    1756                                                 return;
    1757 
    1758                                         //if (IV2[0] != IV1[0])
    1759                                         //      std::cout << "!" << std::flush;
    1760                                 }
    1761                         }
    1762                 }
    1763         }
    1764 }
    1765 
    1766 
     1577        {
     1578            UInt32[] Q = new UInt32[68];
     1579            Q[0] = IV[0];
     1580            Q[1] = IV[3];
     1581            Q[2] = IV[2];
     1582            Q[3] = IV[1];
     1583
     1584            UInt32[] q4mask = new UInt32[1 << 6];
     1585            for (UInt32 k = 0; k < q4mask.Length; ++k)
     1586                q4mask[k] = ((k << 13) ^ (k << 19)) & 0x01c0e000;
     1587
     1588            UInt32[] q9mask = new UInt32[1 << 5], q10mask = new UInt32[1 << 5];
     1589            for (UInt32 k = 0; k < q9mask.Length; ++k)
     1590            {
     1591                UInt32 msk = (k << 5) ^ (k << 13) ^ (k << 17) ^ (k << 24);
     1592                q9mask[k] = msk & 0x00084000;
     1593                q10mask[k] = msk & 0x18000020;
     1594            }
     1595
     1596            UInt32[] q9mask2 = new UInt32[1 << 10];
     1597            for (UInt32 k = 0; k < q9mask2.Length; ++k)
     1598                q9mask2[k] = ((k << 1) ^ (k << 7) ^ (k << 14) ^ (k << 15) ^ (k << 22)) & 0x6074041c;
     1599
     1600
     1601            while (true)
     1602            {
     1603                if (IsStopped)
     1604                    return;
     1605
     1606                UInt32 aa1 = Q[Qoff] & 0x80000000;
     1607                UInt32 bb1 = 0x80000000 ^ aa1;
     1608
     1609                Q[Qoff + 2] = (xrng64() & 0x71de7799) | 0x0c008840 | bb1;
     1610                Q[Qoff + 3] = (xrng64() & 0x01c06601) | 0x3e1f0966 | (Q[Qoff + 2] & 0x80000018);
     1611                Q[Qoff + 4] = 0x3a040010 | (Q[Qoff + 3] & 0x80000601);
     1612                Q[Qoff + 5] = (xrng64() & 0x03c0e000) | 0x482f0e50 | aa1;
     1613                Q[Qoff + 6] = (xrng64() & 0x600c0000) | 0x05e2ec56 | aa1;
     1614                Q[Qoff + 7] = (xrng64() & 0x604c203e) | 0x16819e01 | bb1 | (Q[Qoff + 6] & 0x01000000);
     1615                Q[Qoff + 8] = (xrng64() & 0x604c7c1c) | 0x043283e0 | (Q[Qoff + 7] & 0x80000002);
     1616                Q[Qoff + 9] = (xrng64() & 0x00002800) | 0x1c0101c1 | (Q[Qoff + 8] & 0x80001000);
     1617                Q[Qoff + 10] = 0x078bcbc0 | bb1;
     1618                Q[Qoff + 11] = (xrng64() & 0x07800000) | 0x607dc7df | bb1;
     1619                Q[Qoff + 12] = (xrng64() & 0x00f00f7f) | 0x00081080 | (Q[Qoff + 11] & 0xe7000000);
     1620                Q[Qoff + 13] = (xrng64() & 0x00701f77) | 0x3f0fe008 | aa1;
     1621                Q[Qoff + 14] = (xrng64() & 0x00701f77) | 0x408be088 | aa1;
     1622                Q[Qoff + 15] = (xrng64() & 0x00ff3ff7) | 0x7d000000;
     1623                Q[Qoff + 16] = (xrng64() & 0x4ffdffff) | 0x20000000 | (~Q[Qoff + 15] & 0x00020000);
     1624
     1625                MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     1626                MD5_REVERSE_STEP(block, Q, 6, 0xa8304613, 17);
     1627                MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     1628                MD5_REVERSE_STEP(block, Q, 11, 0x895cd7be, 22);
     1629                MD5_REVERSE_STEP(block, Q, 14, 0xa679438e, 17);
     1630                MD5_REVERSE_STEP(block, Q, 15, 0x49b40821, 22);
     1631
     1632                UInt32 tt17 = GG(Q[Qoff + 16], Q[Qoff + 15], Q[Qoff + 14]) + Q[Qoff + 13] + 0xf61e2562;
     1633                UInt32 tt18 = Q[Qoff + 14] + 0xc040b340 + block[6];
     1634                UInt32 tt19 = Q[Qoff + 15] + 0x265e5a51 + block[11];
     1635
     1636                UInt32 tt0 = FF(Q[Qoff + 0], Q[Qoff - 1], Q[Qoff - 2]) + Q[Qoff - 3] + 0xd76aa478;
     1637                UInt32 tt1 = Q[Qoff - 2] + 0xe8c7b756;
     1638
     1639                UInt32 q1a = 0x04200040 | (Q[Qoff + 2] & 0xf01e1080);
     1640
     1641                UInt32 counter = 0;
     1642                while (counter < (1 << 12))
     1643                {
     1644                    if (IsStopped)
     1645                        return;
     1646
     1647                    ++counter;
     1648
     1649                    UInt32 q1 = q1a | (xrng64() & 0x01c0e71f);
     1650                    UInt32 m1 = Q[Qoff + 2] - q1;
     1651                    m1 = RR(m1, 12) - FF(q1, Q[Qoff + 0], Q[Qoff - 1]) - tt1;
     1652
     1653                    UInt32 q16 = Q[Qoff + 16];
     1654                    UInt32 q17 = tt17 + m1;
     1655                    q17 = RL(q17, 5) + q16;
     1656                    if (0x40000000 != ((q17 ^ q16) & 0xc0008008)) continue;
     1657                    if (0 != (q17 & 0x00020000)) continue;
     1658
     1659                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
     1660                    q18 = RL(q18, 9); q18 += q17;
     1661                    if (0x00020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     1662
     1663                    UInt32 q19 = GG(q18, q17, q16) + tt19;
     1664                    q19 = RL(q19, 14); q19 += q18;
     1665                    if (0 != (q19 & 0x80020000)) continue;
     1666
     1667                    UInt32 m0 = q1 - Q[Qoff + 0];
     1668                    m0 = RR(m0, 7) - tt0;
     1669
     1670                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
     1671                    q20 = RL(q20, 20); q20 += q19;
     1672                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     1673
     1674                    Q[Qoff + 1] = q1;
     1675                    Q[Qoff + 17] = q17;
     1676                    Q[Qoff + 18] = q18;
     1677                    Q[Qoff + 19] = q19;
     1678                    Q[Qoff + 20] = q20;
     1679
     1680                    block[0] = m0;
     1681                    block[1] = m1;
     1682                    MD5_REVERSE_STEP(block, Q, 2, 0x242070db, 17);
     1683
     1684                    counter = 0;
     1685                    break;
     1686                }
     1687                if (counter != 0)
     1688                    continue;
     1689
     1690                UInt32 q4b = Q[Qoff + 4];
     1691                UInt32 q9b = Q[Qoff + 9];
     1692                UInt32 q10b = Q[Qoff + 10];
     1693                UInt32 tt21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d;
     1694
     1695                counter = 0;
     1696                while (counter < (1 << 6))
     1697                {
     1698                    if (IsStopped)
     1699                        return;
     1700
     1701                    Q[Qoff + 4] = q4b ^ q4mask[counter];
     1702                    ++counter;
     1703                    MD5_REVERSE_STEP(block, Q, 5, 0x4787c62a, 12);
     1704                    UInt32 q21 = tt21 + block[5];
     1705                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
     1706                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     1707
     1708                    Q[Qoff + 21] = q21;
     1709                    MD5_REVERSE_STEP(block, Q, 3, 0xc1bdceee, 22);
     1710                    MD5_REVERSE_STEP(block, Q, 4, 0xf57c0faf, 7);
     1711                    MD5_REVERSE_STEP(block, Q, 7, 0xfd469501, 22);
     1712
     1713                    UInt32 tt10 = Q[Qoff + 7] + 0xffff5bb1;
     1714                    UInt32 tt22 = GG(Q[Qoff + 21], Q[Qoff + 20], Q[Qoff + 19]) + Q[Qoff + 18] + 0x02441453;
     1715                    UInt32 tt23 = Q[Qoff + 19] + 0xd8a1e681 + block[15];
     1716                    UInt32 tt24 = Q[Qoff + 20] + 0xe7d3fbc8 + block[4];
     1717
     1718                    UInt32 counter2 = 0;
     1719                    while (counter2 < (1 << 5))
     1720                    {
     1721                        if (IsStopped)
     1722                            return;
     1723
     1724                        UInt32 q10 = q10b ^ q10mask[counter2];
     1725                        UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     1726                        UInt32 q9 = q9b ^ q9mask[counter2];
     1727                        ++counter2;
     1728
     1729                        m10 -= FF(q10, q9, Q[Qoff + 8]) + tt10;
     1730
     1731                        UInt32 aa = Q[Qoff + 21];
     1732                        UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
     1733                        if (0 != (dd & 0x80000000)) continue;
     1734
     1735                        UInt32 bb = Q[Qoff + 20];
     1736                        UInt32 cc = tt23 + GG(dd, aa, bb);
     1737                        if (0 != (cc & 0x20000)) continue;
     1738                        cc = RL(cc, 14) + dd;
     1739                        if (0 != (cc & 0x80000000)) continue;
     1740
     1741                        bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
     1742                        if (0 == (bb & 0x80000000)) continue;
     1743
     1744                        block[10] = m10;
     1745                        Q[Qoff + 9] = q9;
     1746                        Q[Qoff + 10] = q10;
     1747                        MD5_REVERSE_STEP(block, Q, 13, 0xfd987193, 12);
     1748
     1749                        for (UInt32 k9 = 0; k9 < (1 << 10); )
     1750                        {
     1751                            if (IsStopped)
     1752                                return;
     1753
     1754                            UInt32 a = aa, b = bb, c = cc, d = dd;
     1755                            Q[Qoff + 9] = q9 ^ q9mask2[k9]; ++k9;
     1756                            MD5_REVERSE_STEP(block, Q, 8, 0x698098d8, 7);
     1757                            MD5_REVERSE_STEP(block, Q, 9, 0x8b44f7af, 12);
     1758                            MD5_REVERSE_STEP(block, Q, 12, 0x6b901122, 7);
     1759
     1760                            MD5_STEP(GG, ref a, b, c, d, block[9], 0x21e1cde6, 5);
     1761                            MD5_STEP(GG, ref d, a, b, c, block[14], 0xc33707d6, 9);
     1762                            MD5_STEP(GG, ref c, d, a, b, block[3], 0xf4d50d87, 14);
     1763                            MD5_STEP(GG, ref b, c, d, a, block[8], 0x455a14ed, 20);
     1764                            MD5_STEP(GG, ref a, b, c, d, block[13], 0xa9e3e905, 5);
     1765                            MD5_STEP(GG, ref d, a, b, c, block[2], 0xfcefa3f8, 9);
     1766                            MD5_STEP(GG, ref c, d, a, b, block[7], 0x676f02d9, 14);
     1767                            MD5_STEP(GG, ref b, c, d, a, block[12], 0x8d2a4c8a, 20);
     1768                            MD5_STEP(HH, ref a, b, c, d, block[5], 0xfffa3942, 4);
     1769                            MD5_STEP(HH, ref d, a, b, c, block[8], 0x8771f681, 11);
     1770
     1771                            c += HH(d, a, b) + block[11] + 0x6d9d6122;
     1772                            if (0 == (c & (1 << 15)))
     1773                                continue;
     1774                            c = (c << 16 | c >> 16) + d;
     1775
     1776                            MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
     1777                            MD5_STEP(HH, ref a, b, c, d, block[1], 0xa4beea44, 4);
     1778                            MD5_STEP(HH, ref d, a, b, c, block[4], 0x4bdecfa9, 11);
     1779                            MD5_STEP(HH, ref c, d, a, b, block[7], 0xf6bb4b60, 16);
     1780                            MD5_STEP(HH, ref b, c, d, a, block[10], 0xbebfbc70, 23);
     1781                            MD5_STEP(HH, ref a, b, c, d, block[13], 0x289b7ec6, 4);
     1782                            MD5_STEP(HH, ref d, a, b, c, block[0], 0xeaa127fa, 11);
     1783                            MD5_STEP(HH, ref c, d, a, b, block[3], 0xd4ef3085, 16);
     1784                            MD5_STEP(HH, ref b, c, d, a, block[6], 0x04881d05, 23);
     1785                            MD5_STEP(HH, ref a, b, c, d, block[9], 0xd9d4d039, 4);
     1786                            MD5_STEP(HH, ref d, a, b, c, block[12], 0xe6db99e5, 11);
     1787                            MD5_STEP(HH, ref c, d, a, b, block[15], 0x1fa27cf8, 16);
     1788                            MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
     1789                            if (0 != ((b ^ d) & 0x80000000))
     1790                                continue;
     1791
     1792                            MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     1793                            if (0 != ((a ^ c) >> 31)) continue;
     1794                            MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
     1795                            if (0 == ((b ^ d) >> 31)) continue;
     1796                            MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
     1797                            if (0 != ((a ^ c) >> 31)) continue;
     1798                            MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
     1799                            if (0 != ((b ^ d) >> 31)) continue;
     1800                            MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
     1801                            if (0 != ((a ^ c) >> 31)) continue;
     1802                            MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
     1803                            if (0 != ((b ^ d) >> 31)) continue;
     1804                            MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
     1805                            if (0 != ((a ^ c) >> 31)) continue;
     1806                            MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
     1807                            if (0 != ((b ^ d) >> 31)) continue;
     1808                            MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
     1809                            if (0 != ((a ^ c) >> 31)) continue;
     1810                            MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
     1811                            if (0 != ((b ^ d) >> 31)) continue;
     1812                            MD5_STEP(II, ref  c, d, a, b, block[6], 0xa3014314, 15);
     1813                            if (0 != ((a ^ c) >> 31)) continue;
     1814                            MD5_STEP(II, ref  b, c, d, a, block[13], 0x4e0811a1, 21);
     1815                            if (0 == ((b ^ d) >> 31)) continue;
     1816                            MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
     1817                            if (0 != ((a ^ c) >> 31)) continue;
     1818                            MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
     1819                            if (0 != ((b ^ d) >> 31)) continue;
     1820                            MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
     1821                            if (0 != ((a ^ c) >> 31)) continue;
     1822                            MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
     1823
     1824                            //std::cout << "." << std::flush;
     1825
     1826                            UInt32[] block2 = new UInt32[16];
     1827                            UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
     1828                            for (int t = 0; t < 4; ++t)
     1829                            {
     1830                                IV1[t] = IV[t];
     1831                                IV2[t] = IV[t] + ((UInt32)1 << 31);
     1832                            }
     1833                            IV2[1] += (1 << 25);
     1834                            IV2[2] += (1 << 25);
     1835                            IV2[3] += (1 << 25);
     1836
     1837                            for (int t = 0; t < 16; ++t)
     1838                                block2[t] = block[t];
     1839                            block2[4] += (UInt32)1 << 31;
     1840                            block2[11] -= 1 << 15;
     1841                            block2[14] += (UInt32)1 << 31;
     1842
     1843                            md5_compress(IV1, block);
     1844                            md5_compress(IV2, block2);
     1845                            if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1846                                return;
     1847
     1848                            //if (IV2[0] != IV1[0])
     1849                            //  std::cout << "!" << std::flush;
     1850                        }
     1851                    }
     1852                }
     1853            }
     1854        }
     1855
     1856        private bool IsStopped { get; set; }
     1857
     1858        public void Stop()
     1859        {
     1860            IsStopped = true;
     1861        }
    17671862    }
    17681863}
  • trunk/CrypPlugins/MD5Collider/MD5Collider.cs

    r1055 r1127  
    1414    [Author("Holger Pretzsch", "mail@holger-pretzsch.de", "Uni Duisburg-Essen", "http://www.uni-due.de")]
    1515    [PluginInfo(false, "MD5Collider", "MD5 hash collider", "MD5Collider/DetailedDescription/Description.xaml", "MD5Collider/MD5Collider.png")]
    16     [EncryptionType(EncryptionType.Classic)]
    1716    class MD5Collider : ICryptographicHash
    1817    {
    1918        private MD5ColliderSettings settings = new MD5ColliderSettings();
    2019        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     20
     21        IMD5ColliderAlgorithm collider = new StevensCollider();
    2122
    2223        public event Cryptool.PluginBase.StatusChangedEventHandler OnPluginStatusChanged;
     
    3233        public void PostExecution() { Dispose(); }
    3334        public void Pause() { }
    34         public void Stop() { }
     35        public void Stop() { collider.Stop(); }
    3536        public void Initialize() { }
    3637
     
    114115            ProgressChanged(0.5, 1.0);
    115116
    116             IMD5ColliderAlgorithm collider = new StevensCollider();
    117 
    118117            collider.RandomSeed = RandomSeed;
    119118            collider.FindCollision();
Note: See TracChangeset for help on using the changeset viewer.