Changeset 1171


Ignore:
Timestamp:
Feb 23, 2010, 3:35:21 PM (12 years ago)
Author:
pretzsch
Message:

+ MD5Collider: Added quick watch presentation

Location:
trunk/CrypPlugins/MD5Collider
Files:
11 added
6 edited

Legend:

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

    r1127 r1171  
    33using System.Linq;
    44using System.Text;
     5using System.ComponentModel;
    56
    6 namespace Cryptool.MD5Collider.Algorithm
     7namespace Cryptool.Plugins.MD5Collider.Algorithm
    78{
    8     interface IMD5ColliderAlgorithm
     9    public interface IMD5ColliderAlgorithm : INotifyPropertyChanged
    910    {
    1011        byte[] FirstCollidingData { get; }
     
    1213        byte[] RandomSeed { get; set; }
    1314
     15        TimeSpan ElapsedTime { get; }
     16
    1417        void FindCollision();
    1518
    1619        void Stop();
     20
     21        string Status { get; set; }
     22
     23        int MatchProgressMax { get; }
     24        int MatchProgress { get; }
    1725    }
    1826}
  • trunk/CrypPlugins/MD5Collider/Algorithm/KlimaTunnelsCollider.cs

    r1127 r1171  
    55using System.Security.Cryptography;
    66
    7 namespace Cryptool.MD5Collider.Algorithm
     7namespace Cryptool.Plugins.MD5Collider.Algorithm
    88{
    9     class KlimaTunnelsCollider : IMD5ColliderAlgorithm
     9    class KlimaTunnelsCollider : MD5ColliderBase
    1010    {
    11         public byte[] FirstCollidingData { get; private set; }
    12         public byte[] SecondCollidingData { get; private set; }
    13         public byte[] RandomSeed { get; set; }
    14 
    15         public void FindCollision()
     11        protected override void PerformFindCollision()
    1612        {
    1713            byte[] seedBytedMd5 = MD5.Create().ComputeHash(RandomSeed);
     
    253249        {
    254250            int i;
     251
     252            MatchProgressMax = 8;
     253            Status = StatusConstants.FINDING_BLOCK1;
    255254
    256255            UInt32[] Q = new UInt32[65], x = new UInt32[16];
     
    876875            for (; ; )
    877876            {
     877                MatchProgress = 1;
    878878                /* a1 */
    879879                Q[1] = rng();
     
    10391039                for (Q10 = 0; Q10 < 8; Q10++)//3 bits
    10401040                {
     1041                    MatchProgress = 2;
     1042
    10411043                    Q[10] = tempq10; Q[9] = tempq9; Q[13] = tempq13; x[4] = tempx4; x[15] = tempx15;
    10421044                    Q[20] = tempq20; Q[21] = tempq21;
     
    10581060                    for (Q20 = 0; Q20 < 64; Q20++)//6 bits, 64
    10591061                    {
     1062                        MatchProgress = 3;
     1063
    10601064                        Q[3] = tempq3; Q[4] = tempq4; x[1] = tempx1; x[15] = tempx15;
    10611065                        Q[20] = tempq20 ^ maskQ20[Q20];
     
    10841088                        for (Q13 = 0; Q13 < 4096; Q13++)//12 bits
    10851089                        {
     1090                            MatchProgress = 4;
     1091
    10861092                            Q[3] = tempq3; Q[4] = tempq4; Q[14] = tempq14;
    10871093                            Q[13] = tempq13 ^ maskQ13[Q13];
     
    11161122                            for (Q14 = 0; Q14 < 512; Q14++)
    11171123                            {
     1124                                MatchProgress = 5;
     1125
    11181126                                constxxx = constxx + maskQ14[Q14];
    11191127                                if ((constxxx & 0x03ffffd0) != 0) { continue; }
     
    11271135                                for (Q4 = 0; Q4 < 1; Q4++)//tunnel Q4,26 not included
    11281136                                {
     1137                                    MatchProgress = 6;
     1138
    11291139                                    Q[4] = Q[4] ^ 0x02000000;
    11301140                                    x[4] = RR(Q[5] - Q[4], 7) - F(Q[4], Q[3], Q[2]) - Q[1] - 0xf57c0faf;
     
    11591169                                    for (Q9 = 0; Q9 < 8; Q9++)//8
    11601170                                    {
     1171                                        MatchProgress = 7;
     1172
    11611173                                        Q[9] = tempq9 ^ mask_Q9[Q9];
    11621174                                        //x[ 8] = RR(Q[ 9]-Q[ 8], 7) - F(Q[ 8],Q[ 7],Q[ 6]) - Q[ 5] - 0x698098d8;
     
    13361348                                        for (i = 0; i < 4; i++) { P_IHV1[i] = IHV1[i]; P_HIHV1[i] = HIHV1[i]; }
    13371349
     1350                                        MatchProgress = 8;
    13381351
    13391352                                        while (B2() != 0) ;
     
    13571370            UInt32 zavorka_Q17, zavorka_Q19, zavorka_Q20, zavorka_Q23, zavorka_Q35, zavorka_Q62;
    13581371            UInt32 i, Hi, Lo, jednicky, spolecna_maska;
     1372
     1373            Status = StatusConstants.FINDING_BLOCK2;
     1374            MatchProgressMax = 5;
    13591375
    13601376            AA0 = QM3 = P_IHV1[0]; DD0 = QM2 = P_IHV1[3]; CC0 = QM1 = P_IHV1[2]; BB0 = QM0 = P_IHV1[1];
     
    14961512            for (cq16 = 0; cq16 < longmask[26]; cq16++)
    14971513            {
     1514                MatchProgress = 1;
     1515
    14981516                Q[1] = temp2Q1; Q[2] = temp2Q2; Q[4] = temp2Q4; Q[9] = temp2Q9;
    14991517
     
    15271545                for (cq1q2 = 0; cq1q2 < longmask[jednicky + 1]; cq1q2++)
    15281546                {
     1547                    MatchProgress = 2;
     1548
    15291549                    Q[4] = temp2Q4; Q[9] = temp2Q9;
    15301550
     
    15561576                    for (cq4 = 0; cq4 < 64; cq4++)
    15571577                    {
     1578                        MatchProgress = 3;
     1579
    15581580                        Hi = (cq4 & 0x00000038) << 19;
    15591581                        Lo = (cq4 & 0x00000007) << 13;
     
    15711593                        for (cq9 = 0; cq9 < 256; cq9++)
    15721594                        {
     1595                            MatchProgress = 4;
     1596
    15731597                            Q[9] = temp2Q9 ^ mask2Q9[cq9];
    15741598                            x[8] = RR(Q[9] - Q[8], 7) - F(Q[8], Q[7], Q[6]) - Q[5] - 0x698098d8;
     
    16861710                            if (hash1.Union(hash2).Count() == hash1.Intersect(hash2).Count())
    16871711                            {
     1712                                MatchProgress = 5;
     1713
    16881714                                FirstCollidingData = v1;
    16891715                                SecondCollidingData = v2;
     
    16981724        /*=========================================================*/
    16991725
    1700 
    1701         #region IMD5ColliderAlgorithm Member
    1702 
    1703 
    1704         public void Stop()
     1726        protected override void PerformStop()
    17051727        {
    17061728            throw new NotImplementedException();
    17071729        }
    1708 
    1709         #endregion
    17101730    }
    17111731}
  • trunk/CrypPlugins/MD5Collider/Algorithm/StevensCollider.cs

    r1127 r1171  
    66using System.Threading;
    77
    8 namespace Cryptool.MD5Collider.Algorithm
     8namespace Cryptool.Plugins.MD5Collider.Algorithm
    99{
    10     class StevensCollider : IMD5ColliderAlgorithm
     10    class StevensCollider : MD5ColliderBase
    1111    {
    12         public byte[] FirstCollidingData { get; private set; }
    13 
    14         public byte[] SecondCollidingData { get; private set; }
    15 
    16         public byte[] RandomSeed { get; set; }
    17 
    18         public void FindCollision()
     12        protected override void PerformFindCollision()
    1913        {
    2014            IsStopped = false;
     
    5246        {
    5347            for (int i = 0; i < sourceArray.Length; i++)
    54             {
    5548                dumpLittleEndianInteger(sourceArray[i], targetArray, targetOffset + i * 4);
    56             }
    5749        }
    5850
     
    6254            if (!BitConverter.IsLittleEndian)
    6355                Array.Reverse(result);
     56
    6457            Array.Copy(result, 0, targetArray, targetOffset, 4);
    6558        }
     
    6962            byte[] bytesInProperOrder = new byte[4];
    7063            Array.Copy(bytes, bytesInProperOrder, 4);
    71 
    7264            if (!BitConverter.IsLittleEndian)
    7365                Array.Reverse(bytesInProperOrder);
     
    9688                msg2block1[t] = msg1block1[t];
    9789            }
     90
    9891            msg2block0[4] += (UInt32)1 << 31; msg2block0[11] += 1 << 15; msg2block0[14] += (UInt32)1 << 31;
    9992            msg2block1[4] += (UInt32)1 << 31; msg2block1[11] -= 1 << 15; msg2block1[14] += (UInt32)1 << 31;
     
    10598            seed32_1 = seed32_2;
    10699            seed32_2 = (seed32_2 ^ (seed32_2 >> 10)) ^ (t ^ (t >> 13));
     100
    107101            return seed32_1;
    108102        }
     
    140134        void find_block0(UInt32[] block, UInt32[] IV)
    141135        {
     136            MatchProgressMax = 9;
     137            MatchProgress = 0;
     138
    142139            UInt32[] Q = new UInt32[68];
    143140            Q[0] = IV[0];
     
    157154            for (UInt32 k = 0; k < q9mask.Length; ++k)
    158155                q9mask[k] = ((k << 1) ^ (k << 2) ^ (k << 5) ^ (k << 7) ^ (k << 8) ^ (k << 10) ^ (k << 11) ^ (k << 13)) & 0x0eb94f16;
    159 
     156           
    160157            while (true)
    161158            {
    162159                if (IsStopped)
    163160                    return;
     161
     162                MatchProgress = 1;
    164163
    165164                Q[Qoff + 1] = xrng64();
     
    200199                        return;
    201200
     201                    MatchProgress = 2;
     202
    202203                    UInt32 q16 = Q[Qoff + 16];
    203204                    UInt32 q17 = ((xrng64() & 0x3ffd7ff7) | (q16 & 0xc0008008)) ^ 0x40000000;
     
    249250                        return;
    250251
     252                    MatchProgress = 3;
     253
    251254                    Q[Qoff + 4] = q4 ^ q4mask[counter2];
    252255                    ++counter2;
     
    281284                            return;
    282285
     286                        MatchProgress = 4;
     287
    283288                        UInt32 q10 = Q[Qoff + 10] ^ (q9q10mask[counter3] & 0x60);
    284289                        Q[Qoff + 9] = q9backup ^ (q9q10mask[counter3] & 0x2000);
     
    310315                            if (IsStopped)
    311316                                return;
     317
     318                            MatchProgress = 5;
    312319
    313320                            UInt32 q9 = Q[Qoff + 9] ^ q9mask[counter4];
     
    334341                                continue;
    335342                            c = (c << 16 | c >> 16) + d;
     343
     344                            MatchProgress = 6;
    336345
    337346                            MD5_STEP(HH, ref b, c, d, a, block[14], 0xfde5380c, 23);
     
    350359                            if (0 != ((b ^ d) & 0x80000000))
    351360                                continue;
     361
     362                            MatchProgress = 7;
    352363
    353364                            MD5_STEP(II, ref a, b, c, d, block[0], 0xf4292244, 6);
     
    398409
    399410                            if (!(wang || stevens)) continue;
     411                            MatchProgress = 8;
    400412
    401413                            UInt32[] IV1 = new UInt32[4], IV2 = new UInt32[4];
     
    416428                                    && (IV2[2] == IV1[2] + (1 << 31) + (1 << 25))
    417429                                    && (IV2[3] == IV1[3] + (1 << 31) + (1 << 25)))
     430                            {
     431                                MatchProgress = 9;
    418432                                return;
     433                            }
    419434
    420435                            //if (IV2[0] != IV1[0] + (1<<31))
     
    548563        void find_block1_stevens_00(UInt32[] block, UInt32[] IV)
    549564        {
     565            MatchProgressMax = 5;
     566            MatchProgress = 0;
     567
    550568            UInt32[] Q = new UInt32[68];
    551569            Q[0] = IV[0];
     
    566584                if (IsStopped)
    567585                    return;
     586
     587                MatchProgress = 1;
    568588
    569589                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    606626                        return;
    607627
     628                    MatchProgress = 2;
     629
    608630                    ++counter;
    609631
     
    672694                        return;
    673695
     696                    MatchProgress = 3;
     697
    674698                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000020);
    675699                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    700724                        if (IsStopped)
    701725                            return;
     726
     727                        MatchProgress = 4;
    702728
    703729                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    791817                        md5_compress(IV2, block2);
    792818                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     819                        {
     820                            MatchProgress = 5;
    793821                            return;
     822                        }
    794823
    795824                        //if (IV2[0] != IV1[0])
     
    802831        void find_block1_stevens_01(UInt32[] block, UInt32[] IV)
    803832        {
     833            MatchProgressMax = 5;
     834            MatchProgress = 0;
     835
    804836            UInt32[] Q = new UInt32[68];
    805837            Q[0] = IV[0];
     
    820852                if (IsStopped)
    821853                    return;
     854
     855                MatchProgress = 1;
    822856
    823857                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    861895                        return;
    862896
     897                    MatchProgress = 2;
     898
    863899                    ++counter;
    864900
     
    928964                        return;
    929965
     966                    MatchProgress = 3;
     967
    930968                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000030);
    931969                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    956994                        if (IsStopped)
    957995                            return;
     996
     997                        MatchProgress = 4;
    958998
    959999                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    10471087                        md5_compress(IV2, block2);
    10481088                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1089                        {
     1090                            MatchProgress = 5;
    10491091                            return;
     1092                        }
    10501093
    10511094                        //if (IV2[0] != IV1[0])
     
    10591102        void find_block1_stevens_10(UInt32[] block, UInt32[] IV)
    10601103        {
     1104            MatchProgressMax = 5;
     1105            MatchProgress = 0;
     1106
    10611107            UInt32[] Q = new UInt32[68];
    10621108            Q[0] = IV[0];
     
    10721118            for (UInt32 k = 0; k < q9mask.Length; ++k)
    10731119                q9mask[k] = ((k << 1) ^ (k << 2) ^ (k << 3) ^ (k << 7) ^ (k << 12) ^ (k << 15) ^ (k << 18) ^ (k << 20)) & 0x2471042a;
    1074 
     1120           
    10751121            while (true)
    10761122            {
    10771123                if (IsStopped)
    10781124                    return;
     1125
     1126                MatchProgress = 1;
    10791127
    10801128                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    11181166                        return;
    11191167
     1168                    MatchProgress = 2;
     1169
    11201170                    ++counter;
    11211171
     
    11841234                        return;
    11851235
     1236                    MatchProgress = 3;
     1237
    11861238                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000004);
    11871239                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    12121264                        if (IsStopped)
    12131265                            return;
     1266
     1267                        MatchProgress = 4;
    12141268
    12151269                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    13051359                        md5_compress(IV2, block2);
    13061360                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1361                        {
     1362                            MatchProgress = 5;
    13071363                            return;
     1364                        }
    13081365
    13091366                        //if (IV2[0] != IV1[0])
     
    13171374        void find_block1_stevens_11(UInt32[] block, UInt32[] IV)
    13181375        {
     1376            MatchProgressMax = 5;
     1377            MatchProgress = 0;
     1378
    13191379            UInt32[] Q = new UInt32[68];
    13201380            Q[0] = IV[0];
     
    13351395                if (IsStopped)
    13361396                    return;
     1397
     1398                MatchProgress = 1;
    13371399
    13381400                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    13761438                        return;
    13771439
     1440                    MatchProgress = 2;
     1441
    13781442                    ++counter;
    13791443
     
    14431507                        return;
    14441508
     1509                    MatchProgress = 3;
     1510
    14451511                    UInt32 q10 = q10b | (q9q10mask[k10] & 0x08000040);
    14461512                    UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    14711537                        if (IsStopped)
    14721538                            return;
     1539
     1540                        MatchProgress = 4;
    14731541
    14741542                        UInt32 a = aa, b = bb, c = cc, d = dd;
     
    15641632                        md5_compress(IV2, block2);
    15651633                        if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1634                        {
     1635                            MatchProgress = 5;
    15661636                            return;
     1637                        }
    15671638
    15681639                        //if (IV2[0] != IV1[0])
     
    15761647        void find_block1_wang(UInt32[] block, UInt32[] IV)
    15771648        {
     1649            MatchProgressMax = 6;
     1650            MatchProgress = 0;
     1651
    15781652            UInt32[] Q = new UInt32[68];
    15791653            Q[0] = IV[0];
     
    15971671            for (UInt32 k = 0; k < q9mask2.Length; ++k)
    15981672                q9mask2[k] = ((k << 1) ^ (k << 7) ^ (k << 14) ^ (k << 15) ^ (k << 22)) & 0x6074041c;
    1599 
    1600 
     1673           
    16011674            while (true)
    16021675            {
    16031676                if (IsStopped)
    16041677                    return;
     1678
     1679                MatchProgress = 1;
    16051680
    16061681                UInt32 aa1 = Q[Qoff] & 0x80000000;
     
    16451720                        return;
    16461721
     1722                    MatchProgress = 2;
     1723
    16471724                    ++counter;
    16481725
     
    16981775                    if (IsStopped)
    16991776                        return;
     1777
     1778                    MatchProgress = 3;
    17001779
    17011780                    Q[Qoff + 4] = q4b ^ q4mask[counter];
     
    17221801                            return;
    17231802
     1803                        MatchProgress = 4;
     1804
    17241805                        UInt32 q10 = q10b ^ q10mask[counter2];
    17251806                        UInt32 m10 = RR(Q[Qoff + 11] - q10, 17);
     
    17511832                            if (IsStopped)
    17521833                                return;
     1834
     1835                            MatchProgress = 5;
    17531836
    17541837                            UInt32 a = aa, b = bb, c = cc, d = dd;
     
    18441927                            md5_compress(IV2, block2);
    18451928                            if (IV2[0] == IV1[0] && IV2[1] == IV1[1] && IV2[2] == IV1[2] && IV2[3] == IV1[3])
     1929                            {
     1930                                MatchProgress = 6;
    18461931                                return;
     1932                            }
    18471933
    18481934                            //if (IV2[0] != IV1[0])
     
    18561942        private bool IsStopped { get; set; }
    18571943
    1858         public void Stop()
     1944        protected override void PerformStop()
    18591945        {
    18601946            IsStopped = true;
  • trunk/CrypPlugins/MD5Collider/MD5Collider.cs

    r1127 r1171  
    88using Cryptool.PluginBase.Miscellaneous;
    99using System.ComponentModel;
    10 using Cryptool.MD5Collider.Algorithm;
     10using Cryptool.Plugins.MD5Collider.Algorithm;
     11using Cryptool.Plugins.MD5Collider.Presentation;
     12using System.Windows.Controls;
    1113
    12 namespace Cryptool.MD5Collider
     14namespace Cryptool.Plugins.MD5Collider
    1315{
    1416    [Author("Holger Pretzsch", "mail@holger-pretzsch.de", "Uni Duisburg-Essen", "http://www.uni-due.de")]
     
    1820        private MD5ColliderSettings settings = new MD5ColliderSettings();
    1921        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     22        private QuickWatchPresentationContainer quickWatchPresentation = new QuickWatchPresentationContainer();
    2023
    21         IMD5ColliderAlgorithm collider = new StevensCollider();
     24        private IMD5ColliderAlgorithm _collider;
     25        private IMD5ColliderAlgorithm Collider
     26        {
     27            get { return _collider; }
     28            set { _collider = value; quickWatchPresentation.Collider = value; }
     29        }
    2230
    2331        public event Cryptool.PluginBase.StatusChangedEventHandler OnPluginStatusChanged;
     
    2836        public Cryptool.PluginBase.ISettings Settings { get { return settings; } }
    2937        public System.Windows.Controls.UserControl Presentation { get { return null; } }
    30         public System.Windows.Controls.UserControl QuickWatchPresentation { get { return null; } }
     38        public System.Windows.Controls.UserControl QuickWatchPresentation { get { return quickWatchPresentation; } }
    3139
    3240        public void PreExecution() { Dispose(); }
    3341        public void PostExecution() { Dispose(); }
    3442        public void Pause() { }
    35         public void Stop() { collider.Stop(); }
     43        public void Stop() { Collider.Stop(); }
    3644        public void Initialize() { }
     45
     46        public MD5Collider()
     47        {
     48            Collider = new StevensCollider();
     49            Collider.Status = "Waiting";
     50
     51            worker = new BackgroundWorker();
     52            worker.DoWork += DoWork;
     53        }
    3754
    3855        private byte[] outputData1;
     
    107124            }
    108125        }
     126       
     127        BackgroundWorker worker;
    109128
    110129        public void Execute()
    111130        {
     131            DoWork(this, null);
     132            return;
     133
     134            if (worker.IsBusy)
     135                return;
     136
     137            worker.RunWorkerAsync();
     138        }
     139
     140        private void GuiLogMessage(string message, NotificationLevel logLevel)
     141        {
     142            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
     143        }
     144
     145        public void DoWork(object o, EventArgs e)
     146        {
     147            GuiLogMessage("DoWork()", NotificationLevel.Debug);
     148            Collider.Status = "Executing";
     149
    112150            if (RandomSeed == null)
    113151                return;
     
    115153            ProgressChanged(0.5, 1.0);
    116154
    117             collider.RandomSeed = RandomSeed;
    118             collider.FindCollision();
     155            Collider.RandomSeed = RandomSeed;
     156            Collider.FindCollision();
    119157
    120             OutputData1 = collider.FirstCollidingData;
    121             OutputData2 = collider.SecondCollidingData;
     158            OutputData1 = Collider.FirstCollidingData;
     159            OutputData2 = Collider.SecondCollidingData;
    122160
    123161            ProgressChanged(1.0, 1.0);
     162
     163            Collider.Status = "Finished";
    124164        }
    125165
  • trunk/CrypPlugins/MD5Collider/MD5Collider.csproj

    r1055 r1171  
    99    <OutputType>Library</OutputType>
    1010    <AppDesignerFolder>Properties</AppDesignerFolder>
    11     <RootNamespace>Cryptool.MD5Collider</RootNamespace>
     11    <RootNamespace>Cryptool.Plugins.MD5Collider</RootNamespace>
    1212    <AssemblyName>MD5Collider</AssemblyName>
    1313    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
     
    5252    <Reference Include="System.Data" />
    5353    <Reference Include="System.Xml" />
     54    <Reference Include="UIAutomationProvider">
     55      <RequiredTargetFramework>3.0</RequiredTargetFramework>
     56    </Reference>
    5457    <Reference Include="WindowsBase">
    5558      <RequiredTargetFramework>3.0</RequiredTargetFramework>
     
    5962    <Compile Include="Algorithm\IMD5ColliderAlgorithm.cs" />
    6063    <Compile Include="Algorithm\KlimaTunnelsCollider.cs" />
     64    <Compile Include="Algorithm\MD5ColliderBase.cs" />
     65    <Compile Include="Algorithm\StatusConstants.cs" />
    6166    <Compile Include="Algorithm\StevensCollider.cs" />
    6267    <Compile Include="MD5Collider.cs" />
    6368    <Compile Include="MD5ColliderSettings.cs" />
     69    <Compile Include="Presentation\Converters\TimeSpanConverter.cs" />
     70    <Compile Include="Presentation\QuickWatchPresentation.xaml.cs">
     71      <DependentUpon>QuickWatchPresentation.xaml</DependentUpon>
     72    </Compile>
     73    <Compile Include="Presentation\QuickWatchPresentationContainer.xaml.cs">
     74      <DependentUpon>QuickWatchPresentationContainer.xaml</DependentUpon>
     75    </Compile>
    6476    <Compile Include="Properties\AssemblyInfo.cs" />
     77    <Compile Include="Properties\Settings.Designer.cs">
     78      <AutoGen>True</AutoGen>
     79      <DesignTimeSharedInput>True</DesignTimeSharedInput>
     80      <DependentUpon>Settings.settings</DependentUpon>
     81    </Compile>
    6582  </ItemGroup>
    6683  <ItemGroup>
    6784    <None Include="key.snk" />
     85    <None Include="Properties\Settings.settings">
     86      <Generator>SettingsSingleFileGenerator</Generator>
     87      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
     88    </None>
    6889  </ItemGroup>
    6990  <ItemGroup>
     
    81102      <SubType>Designer</SubType>
    82103    </Resource>
     104  </ItemGroup>
     105  <ItemGroup>
     106    <Page Include="Presentation\QuickWatchPresentation.xaml">
     107      <SubType>Designer</SubType>
     108      <Generator>MSBuild:Compile</Generator>
     109    </Page>
     110    <Page Include="Presentation\QuickWatchPresentationContainer.xaml">
     111      <SubType>Designer</SubType>
     112      <Generator>MSBuild:Compile</Generator>
     113    </Page>
    83114  </ItemGroup>
    84115  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/MD5Collider/MD5ColliderSettings.cs

    r957 r1171  
    55using Cryptool.PluginBase;
    66
    7 namespace Cryptool.MD5Collider
     7namespace Cryptool.Plugins.MD5Collider
    88{
    99    class MD5ColliderSettings : ISettings
Note: See TracChangeset for help on using the changeset viewer.