Changeset 1187


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

+ MD5Collider: Added logging / display for amount of different binary block permutations tried

Location:
trunk/CrypPlugins/MD5Collider
Files:
1 added
5 edited

Legend:

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

    r1183 r1187  
    1313        byte[] RandomSeed { set; }
    1414        byte[] IHV { set; }
     15        long CombinationsTried { get; }
    1516
    1617        TimeSpan ElapsedTime { get; }
  • trunk/CrypPlugins/MD5Collider/Algorithm/MD5ColliderBase.cs

    r1183 r1187  
    9191            OnPropertyChanged("MatchProgressMax");
    9292            OnPropertyChanged("MatchProgress");
     93            OnPropertyChanged("CombinationsTried");
    9394        }
    9495
     
    102103            StopTimer();
    103104        }
     105
     106        public void LogReturn(int progress)
     107        {
     108            MatchProgress = progress;
     109            CombinationsTried++;
     110        }
     111
     112
    104113
    105114        private void CheckIHV()
     
    126135        }
    127136
    128         #region IMD5ColliderAlgorithm Member
    129 
    130137        private TimeSpan _elapsedTime;
    131138        public TimeSpan ElapsedTime
     
    135142        }
    136143
    137         #endregion
     144        public long CombinationsTried { get; protected set; }
     145
    138146    }
    139147}
  • trunk/CrypPlugins/MD5Collider/Algorithm/StevensCollider.cs

    r1183 r1187  
    138138        void find_block0(UInt32[] block, UInt32[] IV)
    139139        {
    140             MatchProgressMax = 9;
     140            MatchProgressMax = 28;
    141141            MatchProgress = 0;
    142142
     
    158158            for (UInt32 k = 0; k < q9mask.Length; ++k)
    159159                q9mask[k] = ((k << 1) ^ (k << 2) ^ (k << 5) ^ (k << 7) ^ (k << 8) ^ (k << 10) ^ (k << 11) ^ (k << 13)) & 0x0eb94f16;
    160            
     160
    161161            while (true)
    162162            {
    163163                if (IsStopped)
    164164                    return;
    165 
    166                 MatchProgress = 1;
    167165
    168166                Q[Qoff + 1] = xrng64();
     
    203201                        return;
    204202
    205                     MatchProgress = 2;
    206203
    207204                    UInt32 q16 = Q[Qoff + 16];
     
    212209                    q18 = RL(q18, 9); q18 += q17;
    213210                    if (0x00020000 != ((q18 ^ q17) & 0xa0020000))
    214                         continue;
     211                    {
     212                        LogReturn(1);
     213                        continue;
     214                    }
    215215
    216216                    UInt32 q19 = GG(q18, q17, q16) + tt19;
    217217                    q19 = RL(q19, 14); q19 += q18;
    218218                    if (0x80000000 != (q19 & 0x80020000))
    219                         continue;
     219                    {
     220                        LogReturn(2);
     221                        continue;
     222                    }
    220223
    221224                    UInt32 q20 = GG(q19, q18, q17) + tt20;
    222225                    q20 = RL(q20, 20); q20 += q19;
    223226                    if (0x00040000 != ((q20 ^ q19) & 0x80040000))
    224                         continue;
     227                    {
     228                        LogReturn(3);
     229                        continue;
     230                    }
    225231
    226232                    block[1] = q17 - q16; block[1] = RR(block[1], 5); block[1] -= tt17;
     
    239245                }
    240246                if (counter != 0)
     247                {
     248                    LogReturn(4);
    241249                    continue;
     250                }
    242251
    243252                UInt32 q4 = Q[Qoff + 4];
     
    254263                        return;
    255264
    256                     MatchProgress = 3;
    257265
    258266                    Q[Qoff + 4] = q4 ^ q4mask[counter2];
     
    262270                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
    263271                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000))
    264                         continue;
     272                    {
     273                        LogReturn(5);
     274                        continue;
     275                    }
    265276
    266277                    Q[Qoff + 21] = q21;
     
    288299                            return;
    289300
    290                         MatchProgress = 4;
    291301
    292302                        UInt32 q10 = Q[Qoff + 10] ^ (q9q10mask[counter3] & 0x60);
     
    298308                        UInt32 aa = Q[Qoff + 21];
    299309                        UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
    300                         if (0x80000000 != (dd & 0x80000000)) continue;
     310                        if (0x80000000 != (dd & 0x80000000))
     311                        {
     312                            LogReturn(6);
     313                            continue;
     314                        }
    301315
    302316                        UInt32 bb = Q[Qoff + 20];
    303317                        UInt32 cc = tt23 + GG(dd, aa, bb);
    304                         if (0 != (cc & 0x20000)) continue;
     318                        if (0 != (cc & 0x20000))
     319                        {
     320                            LogReturn(7);
     321                            continue;
     322                        }
     323
    305324                        cc = RL(cc, 14) + dd;
    306                         if (0 != (cc & 0x80000000)) continue;
     325                        if (0 != (cc & 0x80000000))
     326                        {
     327                            LogReturn(8);
     328                            continue;
     329                        }
    307330
    308331                        bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    309                         if (0 == (bb & 0x80000000)) continue;
     332                        if (0 == (bb & 0x80000000))
     333                        {
     334                            LogReturn(9);
     335                            continue;
     336                        }
    310337
    311338                        block[10] = m10;
     
    320347                                return;
    321348
    322                             MatchProgress = 5;
    323349
    324350                            UInt32 q9 = Q[Qoff + 9] ^ q9mask[counter4];
     
    343369                            c += HH(d, a, b) + block[11] + 0x6d9d6122;
    344370                            if (0 != (c & (1 << 15)))
     371                            {
     372                                LogReturn(10);
    345373                                continue;
     374                            }
    346375                            c = (c << 16 | c >> 16) + d;
    347376
    348                             MatchProgress = 6;
    349377
    350378                            MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
     
    362390                            MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    363391                            if (0 != ((b ^ d) & 0x80000000))
     392                            {
     393                                LogReturn(11);
    364394                                continue;
    365 
    366                             MatchProgress = 7;
     395                            }
     396
    367397
    368398                            MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    369                             if (0 != ((a ^ c) >> 31)) continue;
     399                            if (0 != ((a ^ c) >> 31))
     400                            {
     401                                LogReturn(12);
     402                                continue;
     403                            }
    370404                            MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    371                             if (0 == ((b ^ d) >> 31)) continue;
     405                            if (0 == ((b ^ d) >> 31))
     406                            {
     407                                LogReturn(13);
     408                                continue;
     409                            }
    372410                            MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    373                             if (0 != ((a ^ c) >> 31)) continue;
     411                            if (0 != ((a ^ c) >> 31))
     412                            {
     413                                LogReturn(14);
     414                                continue;
     415                            }
    374416                            MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    375                             if (0 != ((b ^ d) >> 31)) continue;
     417                            if (0 != ((b ^ d) >> 31))
     418                            {
     419                                LogReturn(15);
     420                                continue;
     421                            }
    376422                            MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    377                             if (0 != ((a ^ c) >> 31)) continue;
     423                            if (0 != ((a ^ c) >> 31))
     424                            {
     425                                LogReturn(16);
     426                                continue;
     427                            }
    378428                            MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    379                             if (0 != ((b ^ d) >> 31)) continue;
     429                            if (0 != ((b ^ d) >> 31))
     430                            {
     431                                LogReturn(17);
     432                                continue;
     433                            }
    380434                            MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    381                             if (0 != ((a ^ c) >> 31)) continue;
     435                            if (0 != ((a ^ c) >> 31))
     436                            {
     437                                LogReturn(18);
     438                                continue;
     439                            }
    382440                            MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    383                             if (0 != ((b ^ d) >> 31)) continue;
     441                            if (0 != ((b ^ d) >> 31))
     442                            {
     443                                LogReturn(19);
     444                                continue;
     445                            }
    384446                            MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    385                             if (0 != ((a ^ c) >> 31)) continue;
     447                            if (0 != ((a ^ c) >> 31))
     448                            {
     449                                LogReturn(20);
     450                                continue;
     451                            }
    386452                            MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    387                             if (0 != ((b ^ d) >> 31)) continue;
     453                            if (0 != ((b ^ d) >> 31))
     454                            {
     455                                LogReturn(21);
     456                                continue;
     457                            }
    388458                            MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    389                             if (0 != ((a ^ c) >> 31)) continue;
     459                            if (0 != ((a ^ c) >> 31))
     460                            {
     461                                LogReturn(22);
     462                                continue;
     463                            }
    390464                            MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    391                             if (0 == ((b ^ d) >> 31)) continue;
     465                            if (0 == ((b ^ d) >> 31))
     466                            {
     467                                LogReturn(23);
     468                                continue;
     469                            }
    392470                            MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    393                             if (0 != ((a ^ c) >> 31)) continue;
     471                            if (0 != ((a ^ c) >> 31))
     472                            {
     473                                LogReturn(24);
     474                                continue;
     475                            }
    394476                            MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    395                             if (0 != ((b ^ d) >> 31)) continue;
     477                            if (0 != ((b ^ d) >> 31))
     478                            {
     479                                LogReturn(25);
     480                                continue;
     481                            }
    396482                            MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    397                             if (0 != ((a ^ c) >> 31)) continue;
     483                            if (0 != ((a ^ c) >> 31))
     484                            {
     485                                LogReturn(26);
     486                                continue;
     487                            }
    398488                            MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    399489
     
    412502                                || ((IHV2 ^ IHV1) & 1) != 0) stevens = false;
    413503
    414                             if (!(wang || stevens)) continue;
    415                             MatchProgress = 8;
     504                            if (!(wang || stevens))
     505                            {
     506                                LogReturn(27);
     507                                continue;
     508                            }
    416509
    417510                            UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
     
    433526                                    && (IV2[3] == IV1[3] + (1 << 31) + (1 << 25)))
    434527                            {
    435                                 MatchProgress = 9;
     528                                LogReturn(28);
    436529                                return;
    437530                            }
     
    567660        void find_block1_stevens_00(UInt32[] block, UInt32[] IV)
    568661        {
    569             MatchProgressMax = 5;
     662            MatchProgressMax = 29;
    570663            MatchProgress = 0;
    571664
     
    588681                if (IsStopped)
    589682                    return;
    590 
    591                 MatchProgress = 1;
    592683
    593684                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    630721                        return;
    631722
    632                     MatchProgress = 2;
    633 
    634723                    ++counter;
    635724
     
    641730                    UInt32 q17 = tt17 + m1;
    642731                    q17 = RL(q17, 5) + q16;
    643                     if (0x80000000 != ((q17 ^ q16) & 0x80008008)) continue;
    644                     if (0 != (q17 & 0x00020000)) continue;
     732                    if (0x80000000 != ((q17 ^ q16) & 0x80008008))
     733                    {
     734                        LogReturn(1);
     735                        continue;
     736                    }
     737
     738                    if (0 != (q17 & 0x00020000))
     739                    {
     740                        LogReturn(2);
     741                        continue;
     742                    }
    645743
    646744                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
    647745                    q18 = RL(q18, 9); q18 += q17;
    648                     if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     746                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000))
     747                    {
     748                        LogReturn(3);
     749                        continue;
     750                    }
    649751
    650752                    UInt32 q19 = GG(q18, q17, q16) + tt19;
    651753                    q19 = RL(q19, 14); q19 += q18;
    652                     if (0x80000000 != (q19 & 0x80020000)) continue;
     754                    if (0x80000000 != (q19 & 0x80020000))
     755                    {
     756                        LogReturn(4);
     757                        continue;
     758                    }
    653759
    654760                    UInt32 m0 = q1 - Q[Qoff + 0];
     
    657763                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    658764                    q20 = RL(q20, 20); q20 += q19;
    659                     if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     765                    if (0x00040000 != ((q20 ^ q19) & 0x80040000))
     766                    {
     767                        LogReturn(5);
     768                        continue;
     769                    }
    660770
    661771                    Q[Qoff + 1] = q1;
     
    671781                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
    672782                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
    673                     if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     783                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000))
     784                    {
     785                        LogReturn(6);
     786                        continue;
     787                    }
    674788                    Q[Qoff + 21] = q21;
    675789
     
    678792                }
    679793                if (counter != 0)
     794                {
     795                    LogReturn(7);
    680796                    continue;
     797                }
    681798
    682799                UInt32 q9b = Q[Qoff + 9];
     
    698815                        return;
    699816
    700                     MatchProgress = 3;
    701 
    702817                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000020);
    703818                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    708823                    UInt32 aa = Q[Qoff + 21];
    709824                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
    710                     if (0 == (dd & 0x80000000)) continue;
     825                    if (0 == (dd & 0x80000000))
     826                    {
     827                        LogReturn(8);
     828                        continue;
     829                    }
    711830
    712831                    UInt32 bb = Q[Qoff + 20];
    713832                    UInt32 cc = tt23 + GG(dd, aa, bb);
    714                     if (0 != (cc & 0x20000)) continue;
     833                    if (0 != (cc & 0x20000))
     834                    {
     835                        LogReturn(9);
     836                        continue;
     837                    }
    715838                    cc = RL(cc, 14) + dd;
    716                     if (0 != (cc & 0x80000000)) continue;
     839                    if (0 != (cc & 0x80000000))
     840                    {
     841                        LogReturn(10);
     842                        continue;
     843                    }
    717844
    718845                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    719                     if (0 == (bb & 0x80000000)) continue;
     846                    if (0 == (bb & 0x80000000))
     847                    {
     848                        LogReturn(11);
     849                        continue;
     850                    }
    720851
    721852                    block[10] = m10;
     
    728859                        if (IsStopped)
    729860                            return;
    730 
    731                         MatchProgress = 4;
    732861
    733862                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    750879                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
    751880                        if (0 != (c & (1 << 15)))
    752                             continue;
     881                        {
     882                            LogReturn(12);
     883                            continue;
     884                        }
    753885                        c = (c << 16 | c >> 16) + d;
    754886
     
    767899                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    768900                        if (0 != ((b ^ d) & 0x80000000))
    769                             continue;
     901                        {
     902                            LogReturn(13);
     903                            continue;
     904                        }
    770905
    771906                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    772                         if (0 != ((a ^ c) >> 31)) continue;
     907                        if (0 != ((a ^ c) >> 31))
     908                        {
     909                            LogReturn(14);
     910                            continue;
     911                        }
    773912                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    774                         if (0 == ((b ^ d) >> 31)) continue;
     913                        if (0 == ((b ^ d) >> 31))
     914                        {
     915                            LogReturn(15);
     916                            continue;
     917                        }
    775918                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    776                         if (0 != ((a ^ c) >> 31)) continue;
     919                        if (0 != ((a ^ c) >> 31))
     920                        {
     921                            LogReturn(16);
     922                            continue;
     923                        }
    777924                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    778                         if (0 != ((b ^ d) >> 31)) continue;
     925                        if (0 != ((b ^ d) >> 31))
     926                        {
     927                            LogReturn(17);
     928                            continue;
     929                        }
    779930                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    780                         if (0 != ((a ^ c) >> 31)) continue;
     931                        if (0 != ((a ^ c) >> 31))
     932                        {
     933                            LogReturn(18);
     934                            continue;
     935                        }
    781936                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    782                         if (0 != ((b ^ d) >> 31)) continue;
     937                        if (0 != ((b ^ d) >> 31))
     938                        {
     939                            LogReturn(19);
     940                            continue;
     941                        }
    783942                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    784                         if (0 != ((a ^ c) >> 31)) continue;
     943                        if (0 != ((a ^ c) >> 31))
     944                        {
     945                            LogReturn(20);
     946                            continue;
     947                        }
    785948                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    786                         if (0 != ((b ^ d) >> 31)) continue;
     949                        if (0 != ((b ^ d) >> 31))
     950                        {
     951                            LogReturn(21);
     952                            continue;
     953                        }
    787954                        MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    788                         if (0 != ((a ^ c) >> 31)) continue;
     955                        if (0 != ((a ^ c) >> 31))
     956                        {
     957                            LogReturn(22);
     958                            continue;
     959                        }
    789960                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    790                         if (0 != ((b ^ d) >> 31)) continue;
     961                        if (0 != ((b ^ d) >> 31))
     962                        {
     963                            LogReturn(23);
     964                            continue;
     965                        }
    791966                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    792                         if (0 != ((a ^ c) >> 31)) continue;
     967                        if (0 != ((a ^ c) >> 31))
     968                        {
     969                            LogReturn(24);
     970                            continue;
     971                        }
    793972                        MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    794                         if (0 == ((b ^ d) >> 31)) continue;
     973                        if (0 == ((b ^ d) >> 31))
     974                        {
     975                            LogReturn(25);
     976                            continue;
     977                        }
    795978                        MD5_STEP(II, ref  a, b, c, d, block[4], 0xf7537e82, 6);
    796                         if (0 != ((a ^ c) >> 31)) continue;
     979                        if (0 != ((a ^ c) >> 31))
     980                        {
     981                            LogReturn(26);
     982                            continue;
     983                        }
    797984                        MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    798                         if (0 != ((b ^ d) >> 31)) continue;
     985                        if (0 != ((b ^ d) >> 31))
     986                        {
     987                            LogReturn(27);
     988                            continue;
     989                        }
    799990                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    800                         if (0 != ((a ^ c) >> 31)) continue;
     991                        if (0 != ((a ^ c) >> 31))
     992                        {
     993                            LogReturn(28);
     994                            continue;
     995                        }
    801996                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    802997
     
    8221017                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
    8231018                        {
    824                             MatchProgress = 5;
     1019                            LogReturn(29);
    8251020                            return;
    8261021                        }
     
    8351030        void find_block1_stevens_01(UInt32[] block, UInt32[] IV)
    8361031        {
    837             MatchProgressMax = 5;
     1032            MatchProgressMax = 30;
    8381033            MatchProgress = 0;
    8391034
     
    8571052                    return;
    8581053
    859                 MatchProgress = 1;
    8601054
    8611055                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    8991093                        return;
    9001094
    901                     MatchProgress = 2;
    9021095
    9031096                    ++counter;
     
    9101103                    UInt32 q17 = tt17 + m1;
    9111104                    q17 = RL(q17, 5) + q16;
    912                     if (0x80000000 != ((q17 ^ q16) & 0x80008008)) continue;
    913                     if (0 != (q17 & 0x00020000)) continue;
     1105                    if (0x80000000 != ((q17 ^ q16) & 0x80008008))
     1106                    {
     1107                        LogReturn(1);
     1108                        continue;
     1109                    }
     1110                    if (0 != (q17 & 0x00020000))
     1111                    {
     1112                        LogReturn(2);
     1113                        continue;
     1114                    }
    9141115
    9151116                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
    9161117                    q18 = RL(q18, 9); q18 += q17;
    917                     if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     1118                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000))
     1119                    {
     1120                        LogReturn(3);
     1121                        continue;
     1122                    }
    9181123
    9191124                    UInt32 q19 = GG(q18, q17, q16) + tt19;
    9201125                    q19 = RL(q19, 14); q19 += q18;
    921                     if (0 != (q19 & 0x80020000)) continue;
     1126                    if (0 != (q19 & 0x80020000))
     1127                    {
     1128                        LogReturn(4);
     1129                        continue;
     1130                    }
    9221131
    9231132                    UInt32 m0 = q1 - Q[Qoff + 0];
     
    9261135                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    9271136                    q20 = RL(q20, 20); q20 += q19;
    928                     if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     1137                    if (0x00040000 != ((q20 ^ q19) & 0x80040000))
     1138                    {
     1139                        LogReturn(5);
     1140                        continue;
     1141                    }
    9291142
    9301143                    Q[Qoff + 1] = q1;
     
    9401153                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
    9411154                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
    942                     if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     1155                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000))
     1156                    {
     1157                        LogReturn(6);
     1158                        continue;
     1159                    }
    9431160
    9441161                    Q[Qoff + 21] = q21;
    9451162
    9461163                    counter = 0;
     1164
     1165                    LogReturn(7);
    9471166                    break;
    9481167                }
    9491168                if (counter != 0)
     1169                {
     1170                    LogReturn(8);
    9501171                    continue;
     1172                }
    9511173
    9521174                UInt32 q9b = Q[Qoff + 9];
     
    9681190                        return;
    9691191
    970                     MatchProgress = 3;
    9711192
    9721193                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000030);
     
    9781199                    UInt32 aa = Q[Qoff + 21];
    9791200                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
    980                     if (0 != (dd & 0x80000000)) continue;
     1201                    if (0 != (dd & 0x80000000))
     1202                    {
     1203                        LogReturn(9);
     1204                        continue;
     1205                    }
    9811206
    9821207                    UInt32 bb = Q[Qoff + 20];
    9831208                    UInt32 cc = tt23 + GG(dd, aa, bb);
    984                     if (0 != (cc & 0x20000)) continue;
     1209                    if (0 != (cc & 0x20000))
     1210                    {
     1211                        LogReturn(10);
     1212                        continue;
     1213                    }
    9851214                    cc = RL(cc, 14) + dd;
    986                     if (0 != (cc & 0x80000000)) continue;
     1215                    if (0 != (cc & 0x80000000))
     1216                    {
     1217                        LogReturn(11);
     1218                        continue;
     1219                    }
    9871220
    9881221                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    989                     if (0 == (bb & 0x80000000)) continue;
     1222                    if (0 == (bb & 0x80000000))
     1223                    {
     1224                        LogReturn(12);
     1225                        continue;
     1226                    }
    9901227
    9911228                    block[10] = m10;
     
    9991236                            return;
    10001237
    1001                         MatchProgress = 4;
    10021238
    10031239                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    10201256                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
    10211257                        if (0 != (c & (1 << 15)))
    1022                             continue;
     1258                        {
     1259                            LogReturn(13);
     1260                            continue;
     1261                        }
    10231262                        c = (c << 16 | c >> 16) + d;
    10241263
     
    10371276                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    10381277                        if (0 != ((b ^ d) & 0x80000000))
    1039                             continue;
     1278                        {
     1279                            LogReturn(14);
     1280                            continue;
     1281                        }
    10401282
    10411283                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1042                         if (0 != ((a ^ c) >> 31)) continue;
     1284                        if (0 != ((a ^ c) >> 31))
     1285                        {
     1286                            LogReturn(15);
     1287                            continue;
     1288                        }
    10431289                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1044                         if (0 == ((b ^ d) >> 31)) continue;
     1290                        if (0 == ((b ^ d) >> 31))
     1291                        {
     1292                            LogReturn(16);
     1293                            continue;
     1294                        }
    10451295                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1046                         if (0 != ((a ^ c) >> 31)) continue;
     1296                        if (0 != ((a ^ c) >> 31))
     1297                        {
     1298                            LogReturn(17);
     1299                            continue;
     1300                        }
    10471301                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1048                         if (0 != ((b ^ d) >> 31)) continue;
     1302                        if (0 != ((b ^ d) >> 31))
     1303                        {
     1304                            LogReturn(18);
     1305                            continue;
     1306                        }
    10491307                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1050                         if (0 != ((a ^ c) >> 31)) continue;
     1308                        if (0 != ((a ^ c) >> 31))
     1309                        {
     1310                            LogReturn(19);
     1311                            continue;
     1312                        }
    10511313                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1052                         if (0 != ((b ^ d) >> 31)) continue;
     1314                        if (0 != ((b ^ d) >> 31))
     1315                        {
     1316                            LogReturn(20);
     1317                            continue;
     1318                        }
    10531319                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1054                         if (0 != ((a ^ c) >> 31)) continue;
     1320                        if (0 != ((a ^ c) >> 31))
     1321                        {
     1322                            LogReturn(21);
     1323                            continue;
     1324                        }
    10551325                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1056                         if (0 != ((b ^ d) >> 31)) continue;
     1326                        if (0 != ((b ^ d) >> 31))
     1327                        {
     1328                            LogReturn(22);
     1329                            continue;
     1330                        }
    10571331                        MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    1058                         if (0 != ((a ^ c) >> 31)) continue;
     1332                        if (0 != ((a ^ c) >> 31))
     1333                        {
     1334                            LogReturn(23);
     1335                            continue;
     1336                        }
    10591337                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1060                         if (0 != ((b ^ d) >> 31)) continue;
     1338                        if (0 != ((b ^ d) >> 31))
     1339                        {
     1340                            LogReturn(24);
     1341                            continue;
     1342                        }
    10611343                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    1062                         if (0 != ((a ^ c) >> 31)) continue;
     1344                        if (0 != ((a ^ c) >> 31))
     1345                        {
     1346                            LogReturn(25);
     1347                            continue;
     1348                        }
    10631349                        MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    1064                         if (0 == ((b ^ d) >> 31)) continue;
     1350                        if (0 == ((b ^ d) >> 31))
     1351                        {
     1352                            LogReturn(26);
     1353                            continue;
     1354                        }
    10651355                        MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    1066                         if (0 != ((a ^ c) >> 31)) continue;
     1356                        if (0 != ((a ^ c) >> 31))
     1357                        {
     1358                            LogReturn(27);
     1359                            continue;
     1360                        }
    10671361                        MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    1068                         if (0 != ((b ^ d) >> 31)) continue;
     1362                        if (0 != ((b ^ d) >> 31))
     1363                        {
     1364                            LogReturn(28);
     1365                            continue;
     1366                        }
    10691367                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1070                         if (0 != ((a ^ c) >> 31)) continue;
     1368                        if (0 != ((a ^ c) >> 31))
     1369                        {
     1370                            LogReturn(29);
     1371                            continue;
     1372                        }
    10711373                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    10721374
     
    10921394                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
    10931395                        {
    1094                             MatchProgress = 5;
     1396                            LogReturn(30);
    10951397                            return;
    10961398                        }
     
    11061408        void find_block1_stevens_10(UInt32[] block, UInt32[] IV)
    11071409        {
    1108             MatchProgressMax = 5;
     1410            MatchProgressMax = 30;
    11091411            MatchProgress = 0;
    11101412
     
    11221424            for (UInt32 k = 0; k < q9mask.Length; ++k)
    11231425                q9mask[k] = ((k << 1) ^ (k << 2) ^ (k << 3) ^ (k << 7) ^ (k << 12) ^ (k << 15) ^ (k << 18) ^ (k << 20)) & 0x2471042a;
    1124            
     1426
    11251427            while (true)
    11261428            {
     
    11281430                    return;
    11291431
    1130                 MatchProgress = 1;
    11311432
    11321433                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    11701471                        return;
    11711472
    1172                     MatchProgress = 2;
    11731473
    11741474                    ++counter;
     
    11811481                    UInt32 q17 = tt17 + m1;
    11821482                    q17 = RL(q17, 5) + q16;
    1183                     if (0x80000000 != ((q17 ^ q16) & 0x80008008)) continue;
    1184                     if (0 != (q17 & 0x00020000)) continue;
     1483                    if (0x80000000 != ((q17 ^ q16) & 0x80008008)) { LogReturn(1); continue; }
     1484                    if (0 != (q17 & 0x00020000)) { LogReturn(2); continue; }
    11851485
    11861486                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
    11871487                    q18 = RL(q18, 9); q18 += q17;
    1188                     if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     1488                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) { LogReturn(3); continue; }
    11891489
    11901490                    UInt32 q19 = GG(q18, q17, q16) + tt19;
    11911491                    q19 = RL(q19, 14); q19 += q18;
    1192                     if (0 != (q19 & 0x80020000)) continue;
     1492                    if (0 != (q19 & 0x80020000)) { LogReturn(4); continue; }
    11931493
    11941494                    UInt32 m0 = q1 - Q[Qoff + 0];
     
    11971497                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    11981498                    q20 = RL(q20, 20); q20 += q19;
    1199                     if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     1499                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) { LogReturn(5); continue; }
    12001500
    12011501                    Q[Qoff + 1] = q1;
     
    12111511                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
    12121512                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
    1213                     if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     1513                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) { LogReturn(6); continue; }
    12141514                    Q[Qoff + 21] = q21;
    12151515
    12161516                    counter = 0;
     1517                    LogReturn(7);
    12171518                    break;
    12181519                }
    12191520                if (counter != 0)
    1220                     continue;
     1521                    { LogReturn(8); continue; }
    12211522
    12221523                UInt32 q9b = Q[Qoff + 9];
     
    12381539                        return;
    12391540
    1240                     MatchProgress = 3;
    12411541
    12421542                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000004);
     
    12481548                    UInt32 aa = Q[Qoff + 21];
    12491549                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
    1250                     if (0 != (dd & 0x80000000)) continue;
     1550                    if (0 != (dd & 0x80000000)) { LogReturn(9); continue; }
    12511551
    12521552                    UInt32 bb = Q[Qoff + 20];
    12531553                    UInt32 cc = tt23 + GG(dd, aa, bb);
    1254                     if (0 != (cc & 0x20000)) continue;
     1554                    if (0 != (cc & 0x20000)) { LogReturn(10); continue; }
    12551555                    cc = RL(cc, 14) + dd;
    1256                     if (0 != (cc & 0x80000000)) continue;
     1556                    if (0 != (cc & 0x80000000)) { LogReturn(11); continue; }
    12571557
    12581558                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    1259                     if (0 == (bb & 0x80000000)) continue;
     1559                    if (0 == (bb & 0x80000000)) { LogReturn(12); continue; }
    12601560
    12611561                    block[10] = m10;
     
    12691569                            return;
    12701570
    1271                         MatchProgress = 4;
    12721571
    12731572                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    12901589                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
    12911590                        if (0 != (c & (1 << 15)))
    1292                             continue;
     1591                            { LogReturn(13); continue; }
    12931592                        c = (c << 16 | c >> 16) + d;
    12941593
     
    13071606                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    13081607                        if (0 != ((b ^ d) & 0x80000000))
    1309                             continue;
     1608                            { LogReturn(14); continue; }
    13101609
    13111610                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1312                         if (0 != ((a ^ c) >> 31)) continue;
     1611                        if (0 != ((a ^ c) >> 31)) { LogReturn(15); continue; }
    13131612                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1314                         if (0 == ((b ^ d) >> 31)) continue;
     1613                        if (0 == ((b ^ d) >> 31)) { LogReturn(16); continue; }
    13151614                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1316                         if (0 != ((a ^ c) >> 31)) continue;
     1615                        if (0 != ((a ^ c) >> 31)) { LogReturn(17); continue; }
    13171616                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1318                         if (0 != ((b ^ d) >> 31)) continue;
     1617                        if (0 != ((b ^ d) >> 31)) { LogReturn(18); continue; }
    13191618                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1320                         if (0 != ((a ^ c) >> 31)) continue;
     1619                        if (0 != ((a ^ c) >> 31)) { LogReturn(19); continue; }
    13211620                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1322                         if (0 != ((b ^ d) >> 31)) continue;
     1621                        if (0 != ((b ^ d) >> 31)) { LogReturn(20); continue; }
    13231622                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1324                         if (0 != ((a ^ c) >> 31)) continue;
     1623                        if (0 != ((a ^ c) >> 31)) { LogReturn(21); continue; }
    13251624                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1326                         if (0 != ((b ^ d) >> 31)) continue;
     1625                        if (0 != ((b ^ d) >> 31)) { LogReturn(22); continue; }
    13271626                        MD5_STEP(II, ref  a, b, c, d, block[8], 0x6fa87e4f, 6);
    1328                         if (0 != ((a ^ c) >> 31)) continue;
     1627                        if (0 != ((a ^ c) >> 31)) { LogReturn(23); continue; }
    13291628                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1330                         if (0 != ((b ^ d) >> 31)) continue;
     1629                        if (0 != ((b ^ d) >> 31)) { LogReturn(24); continue; }
    13311630                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    1332                         if (0 != ((a ^ c) >> 31)) continue;
     1631                        if (0 != ((a ^ c) >> 31)) { LogReturn(25); continue; }
    13331632                        MD5_STEP(II, ref b, c, d, a, block[13], 0x4e0811a1, 21);
    1334                         if (0 == ((b ^ d) >> 31)) continue;
     1633                        if (0 == ((b ^ d) >> 31)) { LogReturn(26); continue; }
    13351634                        MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    1336                         if (0 != ((a ^ c) >> 31)) continue;
     1635                        if (0 != ((a ^ c) >> 31)) { LogReturn(27); continue; }
    13371636                        MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    1338                         if (0 != ((b ^ d) >> 31)) continue;
     1637                        if (0 != ((b ^ d) >> 31)) { LogReturn(28); continue; }
    13391638                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1340                         if (0 != ((a ^ c) >> 31)) continue;
     1639                        if (0 != ((a ^ c) >> 31)) { LogReturn(29); continue; }
    13411640                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    13421641
     
    13641663                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
    13651664                        {
    1366                             MatchProgress = 5;
     1665                            LogReturn(30);
    13671666                            return;
    13681667                        }
     
    13781677        void find_block1_stevens_11(UInt32[] block, UInt32[] IV)
    13791678        {
    1380             MatchProgressMax = 5;
     1679            MatchProgressMax = 30;
    13811680            MatchProgress = 0;
    13821681
     
    14001699                    return;
    14011700
    1402                 MatchProgress = 1;
    14031701
    14041702                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    14421740                        return;
    14431741
    1444                     MatchProgress = 2;
    14451742
    14461743                    ++counter;
     
    14531750                    UInt32 q17 = tt17 + m1;
    14541751                    q17 = RL(q17, 5) + q16;
    1455                     if (0x40000000 != ((q17 ^ q16) & 0xc0008008)) continue;
    1456                     if (0 != (q17 & 0x00020000)) continue;
     1752                    if (0x40000000 != ((q17 ^ q16) & 0xc0008008)) { LogReturn(1); continue; }
     1753                    if (0 != (q17 & 0x00020000)) { LogReturn(2); continue; }
    14571754
    14581755                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
    14591756                    q18 = RL(q18, 9); q18 += q17;
    1460                     if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     1757                    if (0x80020000 != ((q18 ^ q17) & 0xa0020000)) { LogReturn(3); continue; }
    14611758
    14621759                    UInt32 q19 = GG(q18, q17, q16) + tt19;
    14631760                    q19 = RL(q19, 14); q19 += q18;
    1464                     if (0x80000000 != (q19 & 0x80020000)) continue;
     1761                    if (0x80000000 != (q19 & 0x80020000)) { LogReturn(4); continue; }
    14651762
    14661763                    UInt32 m0 = q1 - Q[Qoff + 0];
     
    14691766                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    14701767                    q20 = RL(q20, 20); q20 += q19;
    1471                     if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     1768                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) { LogReturn(5); continue; }
    14721769
    14731770                    Q[Qoff + 1] = q1;
     
    14831780                    UInt32 q21 = GG(Q[Qoff + 20], Q[Qoff + 19], Q[Qoff + 18]) + Q[Qoff + 17] + 0xd62f105d + block[5];
    14841781                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
    1485                     if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     1782                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) { LogReturn(6); continue; }
    14861783
    14871784                    Q[Qoff + 21] = q21;
    14881785
    14891786                    counter = 0;
     1787                    LogReturn(7);
    14901788                    break;
    14911789                }
    14921790                if (counter != 0)
    1493                     continue;
     1791                    { LogReturn(8); continue; }
    14941792
    14951793                UInt32 q9b = Q[Qoff + 9];
     
    15111809                        return;
    15121810
    1513                     MatchProgress = 3;
    15141811
    15151812                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000040);
     
    15211818                    UInt32 aa = Q[Qoff + 21];
    15221819                    UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
    1523                     if (0 == (dd & 0x80000000)) continue;
     1820                    if (0 == (dd & 0x80000000)) { LogReturn(9); continue; }
    15241821
    15251822                    UInt32 bb = Q[Qoff + 20];
    15261823                    UInt32 cc = tt23 + GG(dd, aa, bb);
    1527                     if (0 != (cc & 0x20000)) continue;
     1824                    if (0 != (cc & 0x20000)) { LogReturn(10); continue; }
    15281825                    cc = RL(cc, 14) + dd;
    1529                     if (0 != (cc & 0x80000000)) continue;
     1826                    if (0 != (cc & 0x80000000)) { LogReturn(11); continue; }
    15301827
    15311828                    bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    1532                     if (0 == (bb & 0x80000000)) continue;
     1829                    if (0 == (bb & 0x80000000)) { LogReturn(12); continue; }
    15331830
    15341831                    block[10] = m10;
     
    15421839                            return;
    15431840
    1544                         MatchProgress = 4;
    15451841
    15461842                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    15631859                        c += HH(d, a, b) + block[11] + 0x6d9d6122;
    15641860                        if (0 != (c & (1 << 15)))
    1565                             continue;
     1861                            { LogReturn(13); continue; }
    15661862                        c = (c << 16 | c >> 16) + d;
    15671863
     
    15801876                        MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    15811877                        if (0 != ((b ^ d) & 0x80000000))
    1582                             continue;
     1878                            { LogReturn(14); continue; }
    15831879
    15841880                        MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1585                         if (0 != ((a ^ c) >> 31)) continue;
     1881                        if (0 != ((a ^ c) >> 31)) { LogReturn(15); continue; }
    15861882                        MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1587                         if (0 == ((b ^ d) >> 31)) continue;
     1883                        if (0 == ((b ^ d) >> 31)) { LogReturn(16); continue; }
    15881884                        MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1589                         if (0 != ((a ^ c) >> 31)) continue;
     1885                        if (0 != ((a ^ c) >> 31)) { LogReturn(17); continue; }
    15901886                        MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1591                         if (0 != ((b ^ d) >> 31)) continue;
     1887                        if (0 != ((b ^ d) >> 31)) { LogReturn(18); continue; }
    15921888                        MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1593                         if (0 != ((a ^ c) >> 31)) continue;
     1889                        if (0 != ((a ^ c) >> 31)) { LogReturn(19); continue; }
    15941890                        MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1595                         if (0 != ((b ^ d) >> 31)) continue;
     1891                        if (0 != ((b ^ d) >> 31)) { LogReturn(20); continue; }
    15961892                        MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1597                         if (0 != ((a ^ c) >> 31)) continue;
     1893                        if (0 != ((a ^ c) >> 31)) { LogReturn(21); continue; }
    15981894                        MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1599                         if (0 != ((b ^ d) >> 31)) continue;
     1895                        if (0 != ((b ^ d) >> 31)) { LogReturn(22); continue; }
    16001896                        MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    1601                         if (0 != ((a ^ c) >> 31)) continue;
     1897                        if (0 != ((a ^ c) >> 31)) { LogReturn(23); continue; }
    16021898                        MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1603                         if (0 != ((b ^ d) >> 31)) continue;
     1899                        if (0 != ((b ^ d) >> 31)) { LogReturn(24); continue; }
    16041900                        MD5_STEP(II, ref c, d, a, b, block[6], 0xa3014314, 15);
    1605                         if (0 != ((a ^ c) >> 31)) continue;
     1901                        if (0 != ((a ^ c) >> 31)) { LogReturn(25); continue; }
    16061902                        MD5_STEP(II, ref  b, c, d, a, block[13], 0x4e0811a1, 21);
    1607                         if (0 == ((b ^ d) >> 31)) continue;
     1903                        if (0 == ((b ^ d) >> 31)) { LogReturn(26); continue; }
    16081904                        MD5_STEP(II, ref  a, b, c, d, block[4], 0xf7537e82, 6);
    1609                         if (0 != ((a ^ c) >> 31)) continue;
     1905                        if (0 != ((a ^ c) >> 31)) { LogReturn(27); continue; }
    16101906                        MD5_STEP(II, ref  d, a, b, c, block[11], 0xbd3af235, 10);
    1611                         if (0 != ((b ^ d) >> 31)) continue;
     1907                        if (0 != ((b ^ d) >> 31)) { LogReturn(28); continue; }
    16121908                        MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1613                         if (0 != ((a ^ c) >> 31)) continue;
     1909                        if (0 != ((a ^ c) >> 31)) { LogReturn(29); continue; }
    16141910                        MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    16151911
     
    16371933                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
    16381934                        {
    1639                             MatchProgress = 5;
     1935                            LogReturn(30);
    16401936                            return;
    16411937                        }
     
    16511947        void find_block1_wang(UInt32[] block, UInt32[] IV)
    16521948        {
    1653             MatchProgressMax = 6;
     1949            MatchProgressMax = 30;
    16541950            MatchProgress = 0;
    16551951
     
    16751971            for (UInt32 k = 0; k < q9mask2.Length; ++k)
    16761972                q9mask2[k] = ((k << 1) ^ (k << 7) ^ (k << 14) ^ (k << 15) ^ (k << 22)) & 0x6074041c;
    1677            
     1973
    16781974            while (true)
    16791975            {
     
    16811977                    return;
    16821978
    1683                 MatchProgress = 1;
    16841979
    16851980                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    17242019                        return;
    17252020
    1726                     MatchProgress = 2;
    17272021
    17282022                    ++counter;
     
    17352029                    UInt32 q17 = tt17 + m1;
    17362030                    q17 = RL(q17, 5) + q16;
    1737                     if (0x40000000 != ((q17 ^ q16) & 0xc0008008)) continue;
    1738                     if (0 != (q17 & 0x00020000)) continue;
     2031                    if (0x40000000 != ((q17 ^ q16) & 0xc0008008)) { LogReturn(1); continue; }
     2032                    if (0 != (q17 & 0x00020000)) { LogReturn(2); continue; }
    17392033
    17402034                    UInt32 q18 = GG(q17, q16, Q[Qoff + 15]) + tt18;
    17412035                    q18 = RL(q18, 9); q18 += q17;
    1742                     if (0x00020000 != ((q18 ^ q17) & 0xa0020000)) continue;
     2036                    if (0x00020000 != ((q18 ^ q17) & 0xa0020000)) { LogReturn(3); continue; }
    17432037
    17442038                    UInt32 q19 = GG(q18, q17, q16) + tt19;
    17452039                    q19 = RL(q19, 14); q19 += q18;
    1746                     if (0 != (q19 & 0x80020000)) continue;
     2040                    if (0 != (q19 & 0x80020000)) { LogReturn(4); continue; }
    17472041
    17482042                    UInt32 m0 = q1 - Q[Qoff + 0];
     
    17512045                    UInt32 q20 = GG(q19, q18, q17) + q16 + 0xe9b6c7aa + m0;
    17522046                    q20 = RL(q20, 20); q20 += q19;
    1753                     if (0x00040000 != ((q20 ^ q19) & 0x80040000)) continue;
     2047                    if (0x00040000 != ((q20 ^ q19) & 0x80040000)) { LogReturn(5); continue; }
    17542048
    17552049                    Q[Qoff + 1] = q1;
     
    17642058
    17652059                    counter = 0;
     2060                    LogReturn(6);
    17662061                    break;
    17672062                }
    17682063                if (counter != 0)
    1769                     continue;
     2064                    { LogReturn(7); continue; }
    17702065
    17712066                UInt32 q4b = Q[Qoff + 4];
     
    17802075                        return;
    17812076
    1782                     MatchProgress = 3;
    17832077
    17842078                    Q[Qoff + 4] = q4b ^ q4mask[counter];
     
    17872081                    UInt32 q21 = tt21 + block[5];
    17882082                    q21 = RL(q21, 5); q21 += Q[Qoff + 20];
    1789                     if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) continue;
     2083                    if (0 != ((q21 ^ Q[Qoff + 20]) & 0x80020000)) { LogReturn(8); continue; }
    17902084
    17912085                    Q[Qoff + 21] = q21;
     
    18052099                            return;
    18062100
    1807                         MatchProgress = 4;
    18082101
    18092102                        UInt32 q10 = q10b ^ q10mask[counter2];
     
    18162109                        UInt32 aa = Q[Qoff + 21];
    18172110                        UInt32 dd = tt22 + m10; dd = RL(dd, 9) + aa;
    1818                         if (0 != (dd & 0x80000000)) continue;
     2111                        if (0 != (dd & 0x80000000)) { LogReturn(9); continue; }
    18192112
    18202113                        UInt32 bb = Q[Qoff + 20];
    18212114                        UInt32 cc = tt23 + GG(dd, aa, bb);
    1822                         if (0 != (cc & 0x20000)) continue;
     2115                        if (0 != (cc & 0x20000)) { LogReturn(10); continue; }
    18232116                        cc = RL(cc, 14) + dd;
    1824                         if (0 != (cc & 0x80000000)) continue;
     2117                        if (0 != (cc & 0x80000000)) { LogReturn(11); continue; }
    18252118
    18262119                        bb = tt24 + GG(cc, dd, aa); bb = RL(bb, 20) + cc;
    1827                         if (0 == (bb & 0x80000000)) continue;
     2120                        if (0 == (bb & 0x80000000)) { LogReturn(12); continue; }
    18282121
    18292122                        block[10] = m10;
     
    18372130                                return;
    18382131
    1839                             MatchProgress = 5;
    18402132
    18412133                            UInt32 a = aa, b = bb, c = cc, d = dd;
     
    18582150                            c += HH(d, a, b) + block[11] + 0x6d9d6122;
    18592151                            if (0 == (c & (1 << 15)))
    1860                                 continue;
     2152                                { LogReturn(13); continue; }
    18612153                            c = (c << 16 | c >> 16) + d;
    18622154
     
    18752167                            MD5_STEP(HH, ref b, c, d, a, block[2], 0xc4ac5665, 23);
    18762168                            if (0 != ((b ^ d) & 0x80000000))
    1877                                 continue;
     2169                                { LogReturn(14); continue; }
    18782170
    18792171                            MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
    1880                             if (0 != ((a ^ c) >> 31)) continue;
     2172                            if (0 != ((a ^ c) >> 31)) { LogReturn(15); continue; }
    18812173                            MD5_STEP(II, ref d, a, b, c, block[7], 0x432aff97, 10);
    1882                             if (0 == ((b ^ d) >> 31)) continue;
     2174                            if (0 == ((b ^ d) >> 31)) { LogReturn(16); continue; }
    18832175                            MD5_STEP(II, ref c, d, a, b, block[14], 0xab9423a7, 15);
    1884                             if (0 != ((a ^ c) >> 31)) continue;
     2176                            if (0 != ((a ^ c) >> 31)) { LogReturn(17); continue; }
    18852177                            MD5_STEP(II, ref b, c, d, a, block[5], 0xfc93a039, 21);
    1886                             if (0 != ((b ^ d) >> 31)) continue;
     2178                            if (0 != ((b ^ d) >> 31)) { LogReturn(18); continue; }
    18872179                            MD5_STEP(II, ref a, b, c, d, block[12], 0x655b59c3, 6);
    1888                             if (0 != ((a ^ c) >> 31)) continue;
     2180                            if (0 != ((a ^ c) >> 31)) { LogReturn(19); continue; }
    18892181                            MD5_STEP(II, ref d, a, b, c, block[3], 0x8f0ccc92, 10);
    1890                             if (0 != ((b ^ d) >> 31)) continue;
     2182                            if (0 != ((b ^ d) >> 31)) { LogReturn(20); continue; }
    18912183                            MD5_STEP(II, ref c, d, a, b, block[10], 0xffeff47d, 15);
    1892                             if (0 != ((a ^ c) >> 31)) continue;
     2184                            if (0 != ((a ^ c) >> 31)) { LogReturn(21); continue; }
    18932185                            MD5_STEP(II, ref b, c, d, a, block[1], 0x85845dd1, 21);
    1894                             if (0 != ((b ^ d) >> 31)) continue;
     2186                            if (0 != ((b ^ d) >> 31)) { LogReturn(22); continue; }
    18952187                            MD5_STEP(II, ref a, b, c, d, block[8], 0x6fa87e4f, 6);
    1896                             if (0 != ((a ^ c) >> 31)) continue;
     2188                            if (0 != ((a ^ c) >> 31)) { LogReturn(23); continue; }
    18972189                            MD5_STEP(II, ref d, a, b, c, block[15], 0xfe2ce6e0, 10);
    1898                             if (0 != ((b ^ d) >> 31)) continue;
     2190                            if (0 != ((b ^ d) >> 31)) { LogReturn(24); continue; }
    18992191                            MD5_STEP(II, ref  c, d, a, b, block[6], 0xa3014314, 15);
    1900                             if (0 != ((a ^ c) >> 31)) continue;
     2192                            if (0 != ((a ^ c) >> 31)) { LogReturn(25); continue; }
    19012193                            MD5_STEP(II, ref  b, c, d, a, block[13], 0x4e0811a1, 21);
    1902                             if (0 == ((b ^ d) >> 31)) continue;
     2194                            if (0 == ((b ^ d) >> 31)) { LogReturn(26); continue; }
    19032195                            MD5_STEP(II, ref a, b, c, d, block[4], 0xf7537e82, 6);
    1904                             if (0 != ((a ^ c) >> 31)) continue;
     2196                            if (0 != ((a ^ c) >> 31)) { LogReturn(27); continue; }
    19052197                            MD5_STEP(II, ref d, a, b, c, block[11], 0xbd3af235, 10);
    1906                             if (0 != ((b ^ d) >> 31)) continue;
     2198                            if (0 != ((b ^ d) >> 31)) { LogReturn(28); continue; }
    19072199                            MD5_STEP(II, ref c, d, a, b, block[2], 0x2ad7d2bb, 15);
    1908                             if (0 != ((a ^ c) >> 31)) continue;
     2200                            if (0 != ((a ^ c) >> 31)) { LogReturn(29); continue; }
    19092201                            MD5_STEP(II, ref b, c, d, a, block[9], 0xeb86d391, 21);
    19102202
     
    19322224                            if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
    19332225                            {
    1934                                 MatchProgress = 6;
     2226                                LogReturn(30);
    19352227                                return;
    19362228                            }
  • trunk/CrypPlugins/MD5Collider/MD5Collider.csproj

    r1183 r1187  
    6868    <Compile Include="MD5Collider.cs" />
    6969    <Compile Include="MD5ColliderSettings.cs" />
     70    <Compile Include="Presentation\Converters\LongToStringWithDecimalSeparatorConverter.cs" />
    7071    <Compile Include="Presentation\Converters\TimeSpanConverter.cs" />
    7172    <Compile Include="Presentation\QuickWatchPresentation.xaml.cs">
  • trunk/CrypPlugins/MD5Collider/Presentation/QuickWatchPresentation.xaml

    r1171 r1187  
    33             xmlns:converters="clr-namespace:Cryptool.Plugins.MD5Collider.Presentation.Converters"
    44    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Name="ucQuickWatchPresentation"
    5     Height="70" Width="270" DataContext="{Binding Collider,ElementName=ucQuickWatchPresentation}" Background="AntiqueWhite">
     5    Height="100" Width="270" DataContext="{Binding Collider,ElementName=ucQuickWatchPresentation}" Background="AntiqueWhite">
    66    <UserControl.Resources>
    77        <converters:TimeSpanConverter x:Key="timeSpanConverter"/>
     8        <converters:LongToStringWithDecimalSeparatorConverter x:Key="longConverter"/>
    89    </UserControl.Resources>
    910    <Grid Margin="5, 5, 5, 5">
    1011        <Grid.RowDefinitions>
     12            <RowDefinition/>
    1113            <RowDefinition/>
    1214            <RowDefinition/>
     
    2628        <Label Grid.Row="1" FontSize="16">Match:</Label>
    2729        <ProgressBar Grid.Row="1" Grid.Column="2" Value="{Binding MatchProgress}" Maximum="{Binding MatchProgressMax}"/>
     30
     31
     32        <Label Grid.Row="2" FontSize="16">Tries:</Label>
     33        <Label Grid.Row="3" Grid.Column="1" FontSize="16" Content="{Binding CombinationsTried, Converter={StaticResource longConverter}}"/>
    2834    </Grid>
    2935</UserControl>
Note: See TracChangeset for help on using the changeset viewer.