Changeset 8416


Ignore:
Timestamp:
Oct 17, 2019, 6:36:54 PM (2 years ago)
Author:
Christian Bender
Message:

DCA Components: Translations

Location:
trunk/CrypPlugins
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/DCAKeyRecovery/DCAKeyRecovery.cs

    r8381 r8416  
    842842                            recoveredSubKey0 = Convert.ToString(c1Attack.subkey0, 2).PadLeft(16, '0'),
    843843                            recoveredSubKey1 = Convert.ToString(c1Attack.subkey1, 2).PadLeft(16, '0'),
    844                             testedKeys = 65536
     844                            testedKeys = lastRoundResult.KeyCounter
    845845                        };
    846846
     
    12571257                            recoveredSubKey0 = Convert.ToString(c2Attack.subkey0, 2).PadLeft(16, '0'),
    12581258                            recoveredSubKey1 = Convert.ToString(c2Attack.subkey1, 2).PadLeft(16, '0'),
    1259                             testedKeys = 65536
     1259                            testedKeys = lastRoundResult.KeyCounter
    12601260                        };
    12611261
     
    19431943                            recoveredSubKey0 = Convert.ToString(c3Attack.subkey0, 2).PadLeft(16, '0'),
    19441944                            recoveredSubKey1 = Convert.ToString(c3Attack.subkey1, 2).PadLeft(16, '0'),
    1945                             testedKeys = 65536
     1945                            testedKeys = lastRoundResult.KeyCounter
    19461946                        };
    19471947
  • trunk/CrypPlugins/DCAKeyRecovery/Logic/Cipher1/Cipher1KeyRecovery.cs

    r8264 r8416  
    7878            ResultViewLastRoundEventArgs lastRoundEventArgsIterationResultViewLastRound = null;
    7979            int decryptionCounter = 0;
     80            int keyCounter = 0;
    8081            usedPairCount = 2;
    8182            int roundCounter = 0;
     
    8485
    8586            List<int> possibleKeyList = new List<int>();
    86             for (int i = 0; i < 65535; i++)
     87            for (int i = 0; i <= 65535; i++)
    8788            {
    8889                possibleKeyList.Add(i);
     
    161162                    decryptionCounter++;
    162163                    decryptionCounter++;
     164                    keyCounter++;
    163165
    164166                    decryptedLeftMember = ReverseSBoxBlock(decryptedLeftMember);
     
    299301
    300302            decryptionCounter++;
     303            keyCounter++;
    301304
    302305            inc = 1.0 - progress;
     
    321324
    322325            result.DecryptionCounter = decryptionCounter;
    323 
     326            result.KeyCounter = keyCounter;
     327           
    324328            return result;
    325329        }
  • trunk/CrypPlugins/DCAKeyRecovery/Logic/Cipher2/Cipher2KeyRecovery.cs

    r8264 r8416  
    100100            double progress = 0.0;
    101101            ProgressEventArgs e;
     102            int keyCounter = 0;
    102103
    103104            List<int> possibleKeyList = new List<int>();
    104             for (int i = 0; i < 65535; i++)
     105            for (int i = 0; i <= 65535; i++)
    105106            {
    106107                possibleKeyList.Add(i);
     
    169170                    }
    170171
    171                     UInt16 decryptedLeftMember =
    172                         (UInt16) (ReverseSBoxBlock(ReversePBoxBlock(PartialDecrypt(attack, encryptedPair.LeftMember))) ^
    173                                   item);
    174                     UInt16 decryptedRightMember =
    175                         (UInt16) (ReverseSBoxBlock(
    176                                       ReversePBoxBlock(PartialDecrypt(attack, encryptedPair.RightMember))) ^ item);
     172                    UInt16 decryptedLeftMember = (UInt16) (ReverseSBoxBlock(ReversePBoxBlock(PartialDecrypt(attack, encryptedPair.LeftMember))) ^ item);
     173                    UInt16 decryptedRightMember = (UInt16) (ReverseSBoxBlock( ReversePBoxBlock(PartialDecrypt(attack, encryptedPair.RightMember))) ^ item);
    177174                    decryptionCounter++;
    178175                    decryptionCounter++;
     176                    keyCounter++;
    179177
    180178                    decryptedLeftMember = ReverseSBoxBlock(ReversePBoxBlock(decryptedLeftMember));
     
    351349
    352350            decryptionCounter++;
     351            keyCounter++;
    353352
    354353            //refresh UI
     
    363362
    364363            result.DecryptionCounter = decryptionCounter;
     364            result.KeyCounter = keyCounter;
    365365
    366366            return result;
  • trunk/CrypPlugins/DCAKeyRecovery/Logic/Cipher3/Cipher3KeyRecovery.cs

    r8361 r8416  
    106106            ResultViewLastRoundEventArgs lastRoundEventArgsIterationResultViewLastRound = null;
    107107
     108            int keyCounter = 0;
    108109            int decryptionCounter = 0;
    109110            usedPairCount = 2;
     
    113114
    114115            List<int> possibleKeyList = new List<int>();
    115             for (int i = 0; i < 65535; i++)
     116            for (int i = 0; i <= 65535; i++)
    116117            {
    117118                possibleKeyList.Add(i);
     
    185186                    decryptionCounter++;
    186187                    decryptionCounter++;
     188                    keyCounter++;
    187189
    188190                    decryptedLeftMember = ReverseSBoxBlock(ReversePBoxBlock(decryptedLeftMember));
     
    338340            UInt16 cipherText = encryptedPair2.LeftMember;
    339341
    340             cipherText = (UInt16) (ReverseSBoxBlock(ReversePBoxBlock(PartialDecrypt(attack, cipherText))) ^
    341                                    result.SubKey1);
     342            cipherText = (UInt16) (ReverseSBoxBlock(ReversePBoxBlock(PartialDecrypt(attack, cipherText))) ^ result.SubKey1);
    342343            cipherText = ReverseSBoxBlock(ReversePBoxBlock(cipherText));
    343             ;
    344 
    345344            result.SubKey0 = (ushort) (cipherText ^ plainText);
    346345
    347346            inc = 1.0 - progress;
    348             progress = 1.0;
    349347            e = new ProgressEventArgs()
    350348            {
     
    358356
    359357            decryptionCounter++;
     358            keyCounter++;
    360359
    361360            //refresh UI
     
    368367
    369368            result.DecryptionCounter = decryptionCounter;
     369            result.KeyCounter = keyCounter;
    370370
    371371            return result;
     
    513513
    514514            Cipher3DifferentialKeyRecoveryAttack c3Attack = attack as Cipher3DifferentialKeyRecoveryAttack;
     515
    515516            int partialKey = 0;
    516517
     
    600601                        currentKeysToTestThisRound = loopBorder,
    601602                        currentRecoveredRoundKey = Convert.ToString((ushort)partialKey, 2).PadLeft(16, '0'),
    602                         expectedDifference =
    603                             Convert.ToString((ushort)configuration.ExpectedDifference, 2).PadLeft(16, '0'),
     603                        expectedDifference = Convert.ToString((ushort)configuration.ExpectedDifference, 2).PadLeft(16, '0'),
    604604                        expectedHitCount = (int)(configuration.Probability * configuration.UnfilteredPairList.Count),
    605605                        messagePairCountToExamine = configuration.FilteredPairList.Count
     
    628628
    629629                    //reverse round with the guessed key
    630                     UInt16 leftMemberSingleDecrypted = DecryptSingleRound(encryptedPair.LeftMember, curTry.Key,
    631                         configuration.IsBeforeLast, configuration.IsLast);
    632                     UInt16 rightMemberSingleDecrypted = DecryptSingleRound(encryptedPair.RightMember, curTry.Key,
    633                         configuration.IsBeforeLast, configuration.IsLast);
     630                    UInt16 leftMemberSingleDecrypted = DecryptSingleRound(encryptedPair.LeftMember, curTry.Key, configuration.IsBeforeLast, configuration.IsLast);
     631                    UInt16 rightMemberSingleDecrypted = DecryptSingleRound(encryptedPair.RightMember, curTry.Key, configuration.IsBeforeLast, configuration.IsLast);
    634632
    635633                    if (configuration.IsLast)
     
    732730            roundResult.Probability = bestPossibleKey.Counter / (double) configuration.UnfilteredPairList.Count;
    733731            roundResult.ExpectedProbability = configuration.Probability;
    734             roundResult.KeyCandidateProbabilities = roundResult.KeyCandidateProbabilities
    735                 .OrderByDescending(item => item.Counter).ToList();
     732            roundResult.KeyCandidateProbabilities = roundResult.KeyCandidateProbabilities.OrderByDescending(item => item.Counter).ToList();
    736733
    737734            return roundResult;
  • trunk/CrypPlugins/DCAKeyRecovery/Logic/DifferentialAttackLastRoundResult.cs

    r8216 r8416  
    2424        public UInt16 SubKey1 = 0;
    2525        public int DecryptionCounter = 0;
     26        public int KeyCounter = 0;
    2627    }
    2728}
  • trunk/CrypPlugins/DCAKeyRecovery/Properties/Resources.Designer.cs

    r8364 r8416  
    6262       
    6363        /// <summary>
    64         ///   Sucht eine lokalisierte Zeichenfolge, die Key candidate ähnelt.
     64        ///   Sucht eine lokalisierte Zeichenfolge, die key candidate ähnelt.
    6565        /// </summary>
    6666        internal static string AnyRoundAttackDataColHeader1 {
     
    7171       
    7272        /// <summary>
    73         ///   Sucht eine lokalisierte Zeichenfolge, die Hitcount ähnelt.
     73        ///   Sucht eine lokalisierte Zeichenfolge, die Number of hits ähnelt.
    7474        /// </summary>
    7575        internal static string AnyRoundAttackDataColHeader2 {
     
    134134       
    135135        /// <summary>
    136         ///   Sucht eine lokalisierte Zeichenfolge, die Expected hitcount: ähnelt.
     136        ///   Sucht eine lokalisierte Zeichenfolge, die Expected number of hits: ähnelt.
    137137        /// </summary>
    138138        internal static string AnyRoundExpectedHitCount {
     
    152152       
    153153        /// <summary>
    154         ///   Sucht eine lokalisierte Zeichenfolge, die Count of Messagepairs: ähnelt.
     154        ///   Sucht eine lokalisierte Zeichenfolge, die Count of message pairs: ähnelt.
    155155        /// </summary>
    156156        internal static string AnyRoundMessagePairCount {
     
    161161       
    162162        /// <summary>
    163         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered roundkey: ähnelt.
     163        ///   Sucht eine lokalisierte Zeichenfolge, die Recovered round key: ähnelt.
    164164        /// </summary>
    165165        internal static string AnyRoundRecoveredRoundKey {
     
    170170       
    171171        /// <summary>
    172         ///   Sucht eine lokalisierte Zeichenfolge, die {0} key restore ähnelt.
     172        ///   Sucht eine lokalisierte Zeichenfolge, die {0} key recovery ähnelt.
    173173        /// </summary>
    174174        internal static string AttackLastRoundHeader {
     
    233233       
    234234        /// <summary>
    235         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher selection ähnelt.
     235        ///   Sucht eine lokalisierte Zeichenfolge, die Choice of cipher ähnelt.
    236236        /// </summary>
    237237        internal static string ChoiceOfAlgorithm {
     
    242242       
    243243        /// <summary>
    244         ///   Sucht eine lokalisierte Zeichenfolge, die At this point one of the ciphers contained in the list can be selected. This cipher can be examined by differential cryptanalysis. ähnelt.
     244        ///   Sucht eine lokalisierte Zeichenfolge, die At this point, you can select one of the ciphers contained in the list. This can be examined by differential cryptanalysis. ähnelt.
    245245        /// </summary>
    246246        internal static string ChoiceOfAlgorithmToolTop {
     
    251251       
    252252        /// <summary>
    253         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 1 (16 bit blocksize, 2 subkeys, keylength is 32 bit) ähnelt.
     253        ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 1 (16 bit block size, 2 round keys, 32 bit key length) ähnelt.
    254254        /// </summary>
    255255        internal static string Cipher1 {
     
    260260       
    261261        /// <summary>
    262         ///   Sucht eine lokalisierte Zeichenfolge, die Key candidate ähnelt.
     262        ///   Sucht eine lokalisierte Zeichenfolge, die key candidate ähnelt.
    263263        /// </summary>
    264264        internal static string Cipher1CipherViewCol {
     
    271271        ///   Sucht eine lokalisierte Zeichenfolge, die Total ähnelt.
    272272        /// </summary>
    273         internal static string Cipher1SummaryResultViewTotalSummary1 {
    274             get {
    275                 return ResourceManager.GetString("Cipher1SummaryResultViewTotalSummary1", resourceCulture);
    276             }
    277         }
    278        
    279         /// <summary>
    280         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 2 (16 bit blocksize, 4 subkeys, keylength is 64 bit) ähnelt.
     273        internal static string Cipher1SummaryResultViewTotalSummary {
     274            get {
     275                return ResourceManager.GetString("Cipher1SummaryResultViewTotalSummary", resourceCulture);
     276            }
     277        }
     278       
     279        /// <summary>
     280        ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 2 (16 bit block size, 4 round keys, 64 bit key length) ähnelt.
    281281        /// </summary>
    282282        internal static string Cipher2 {
     
    323323       
    324324        /// <summary>
    325         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 3 (16 bit blocksize, 6 subkeys, keylength is 96 bit) ähnelt.
     325        ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 3 (16 bit block size, 6 round keys, 96 bit key length) ähnelt.
    326326        /// </summary>
    327327        internal static string Cipher3 {
     
    404404       
    405405        /// <summary>
    406         ///   Sucht eine lokalisierte Zeichenfolge, die Ciphertext-pairs ähnelt.
     406        ///   Sucht eine lokalisierte Zeichenfolge, die ciphertext message pairs ähnelt.
    407407        /// </summary>
    408408        internal static string EncryptedMessagePairsInput {
     
    413413       
    414414        /// <summary>
    415         ///   Sucht eine lokalisierte Zeichenfolge, die Input for the ciphertext-pairs ähnelt.
     415        ///   Sucht eine lokalisierte Zeichenfolge, die Input for the ciphertext message pairs ähnelt.
    416416        /// </summary>
    417417        internal static string EncryptedMessagePairsInputToolTip {
     
    422422       
    423423        /// <summary>
     424        ///   Sucht eine lokalisierte Zeichenfolge, die Expected difference ähnelt.
     425        /// </summary>
     426        internal static string ExpectedDifferential {
     427            get {
     428                return ResourceManager.GetString("ExpectedDifferential", resourceCulture);
     429            }
     430        }
     431       
     432        /// <summary>
     433        ///   Sucht eine lokalisierte Zeichenfolge, die Output for the expected difference ähnelt.
     434        /// </summary>
     435        internal static string ExpectedDifferentialToolTip {
     436            get {
     437                return ResourceManager.GetString("ExpectedDifferentialToolTip", resourceCulture);
     438            }
     439        }
     440       
     441        /// <summary>
    424442        ///   Sucht eine lokalisierte Zeichenfolge, die Finished ähnelt.
    425443        /// </summary>
     
    431449       
    432450        /// <summary>
    433         ///   Sucht eine lokalisierte Zeichenfolge, die The output indicates to the PathFinder component that the calculation has been completed ähnelt.
     451        ///   Sucht eine lokalisierte Zeichenfolge, die The output indicates to the DCA PathFinder component that the calculation has been completed. ähnelt.
    434452        /// </summary>
    435453        internal static string FinishedOutputToolTip {
     
    440458       
    441459        /// <summary>
    442         ///   Sucht eine lokalisierte Zeichenfolge, die ENG ähnelt.
     460        ///   Sucht eine lokalisierte Zeichenfolge, die GER ähnelt.
    443461        /// </summary>
    444462        internal static string Lang {
     
    467485       
    468486        /// <summary>
    469         ///   Sucht eine lokalisierte Zeichenfolge, die Number of keys to test: ähnelt.
     487        ///   Sucht eine lokalisierte Zeichenfolge, die Number of keys to be tested: ähnelt.
    470488        /// </summary>
    471489        internal static string LastRoundAttackCurrentKeyOfAll {
     
    521539       
    522540        /// <summary>
    523         ///   Sucht eine lokalisierte Zeichenfolge, die Examined plaintext/keytext pairs: ähnelt.
     541        ///   Sucht eine lokalisierte Zeichenfolge, die Examined plaintext/ciphertext pairs: ähnelt.
    524542        /// </summary>
    525543        internal static string LastRoundAttackNumberOfExaminedPairs {
     
    539557       
    540558        /// <summary>
    541         ///   Sucht eine lokalisierte Zeichenfolge, die Attacked round: ähnelt.
     559        ///   Sucht eine lokalisierte Zeichenfolge, die Attacked encryption round: ähnelt.
    542560        /// </summary>
    543561        internal static string LastRoundAttackRound {
     
    575593       
    576594        /// <summary>
    577         ///   Sucht eine lokalisierte Zeichenfolge, die Expected difference ähnelt.
     595        ///   Sucht eine lokalisierte Zeichenfolge, die Expected difference: ähnelt.
    578596        /// </summary>
    579597        internal static string MessageDifferenceOutput {
     
    593611       
    594612        /// <summary>
    595         ///   Sucht eine lokalisierte Zeichenfolge, die The last subkeys could not be restored. This can happen if one of the previous subkeys was incorrectly calculated. Possibly the parameters in the PathFinder component should be selected again. ähnelt.
     613        ///   Sucht eine lokalisierte Zeichenfolge, die The last round keys could not be restored. This can happen if one of the previous round keys was incorrectly calculated. Possibly the parameters in the DCA PathFinder component should be selected again. ähnelt.
    596614        /// </summary>
    597615        internal static string MessageNoResult {
     
    602620       
    603621        /// <summary>
    604         ///   Sucht eine lokalisierte Zeichenfolge, die Message pair count ähnelt.
     622        ///   Sucht eine lokalisierte Zeichenfolge, die Number of message pairs ähnelt.
    605623        /// </summary>
    606624        internal static string NeededMessageCountOutput {
     
    611629       
    612630        /// <summary>
    613         ///   Sucht eine lokalisierte Zeichenfolge, die Input for the message pair count ähnelt.
     631        ///   Sucht eine lokalisierte Zeichenfolge, die Output for the number of requested message pairs ähnelt.
    614632        /// </summary>
    615633        internal static string NeededMessageCountOutputToolTip {
     
    620638       
    621639        /// <summary>
    622         ///   Sucht eine lokalisierte Zeichenfolge, die The differential cryptanalysis has to be ähnelt.
     640        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis is continued in the ähnelt.
    623641        /// </summary>
    624642        internal static string nextStepTextRun1 {
     
    629647       
    630648        /// <summary>
    631         ///   Sucht eine lokalisierte Zeichenfolge, die continued in the PathFinder component ähnelt.
     649        ///   Sucht eine lokalisierte Zeichenfolge, die DCA PathFinder componend ähnelt.
    632650        /// </summary>
    633651        internal static string nextStepTextRun2 {
     
    638656       
    639657        /// <summary>
    640         ///   Sucht eine lokalisierte Zeichenfolge, die Speed settings ähnelt.
     658        ///   Sucht eine lokalisierte Zeichenfolge, die speed options ähnelt.
    641659        /// </summary>
    642660        internal static string PerformanceSettingsGroup {
     
    656674       
    657675        /// <summary>
    658         ///   Sucht eine lokalisierte Zeichenfolge, die This component performs recovery of key bits from round keys. ähnelt.
     676        ///   Sucht eine lokalisierte Zeichenfolge, die This component performs the recovery of key bits from round keys. ähnelt.
    659677        /// </summary>
    660678        internal static string PluginTooltip {
     
    665683       
    666684        /// <summary>
    667         ///   Sucht eine lokalisierte Zeichenfolge, die Roundkeys ähnelt.
     685        ///   Sucht eine lokalisierte Zeichenfolge, die Round keys ähnelt.
    668686        /// </summary>
    669687        internal static string RoundKeysOutput {
     
    674692       
    675693        /// <summary>
    676         ///   Sucht eine lokalisierte Zeichenfolge, die Output for the roundkeys ähnelt.
     694        ///   Sucht eine lokalisierte Zeichenfolge, die Output of the round keys ähnelt.
    677695        /// </summary>
    678696        internal static string RoundKeysOutputToolTip {
     
    683701       
    684702        /// <summary>
    685         ///   Sucht eine lokalisierte Zeichenfolge, die Decryption count: ähnelt.
     703        ///   Sucht eine lokalisierte Zeichenfolge, die Number of decryptions: ähnelt.
    686704        /// </summary>
    687705        internal static string SummaryResultViewCountOfDecryptions {
     
    692710       
    693711        /// <summary>
    694         ///   Sucht eine lokalisierte Zeichenfolge, die Message count: ähnelt.
     712        ///   Sucht eine lokalisierte Zeichenfolge, die Number of messages: ähnelt.
    695713        /// </summary>
    696714        internal static string SummaryResultViewCountOfMessages {
     
    719737       
    720738        /// <summary>
    721         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered subkey K0: ähnelt.
     739        ///   Sucht eine lokalisierte Zeichenfolge, die Restored round key K0: ähnelt.
    722740        /// </summary>
    723741        internal static string SummaryResultViewRecoveredK0 {
     
    728746       
    729747        /// <summary>
    730         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered subkey K1: ähnelt.
     748        ///   Sucht eine lokalisierte Zeichenfolge, die Restored round key K1: ähnelt.
    731749        /// </summary>
    732750        internal static string SummaryResultViewRecoveredK1 {
     
    737755       
    738756        /// <summary>
    739         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered subkey K2: ähnelt.
     757        ///   Sucht eine lokalisierte Zeichenfolge, die Restored round key K2: ähnelt.
    740758        /// </summary>
    741759        internal static string SummaryResultViewRecoveredK2 {
     
    746764       
    747765        /// <summary>
    748         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered subkey K3: ähnelt.
     766        ///   Sucht eine lokalisierte Zeichenfolge, die Restored round key K3: ähnelt.
    749767        /// </summary>
    750768        internal static string SummaryResultViewRecoveredK3 {
     
    755773       
    756774        /// <summary>
    757         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered subkey K4: ähnelt.
     775        ///   Sucht eine lokalisierte Zeichenfolge, die Restored round key K4: ähnelt.
    758776        /// </summary>
    759777        internal static string SummaryResultViewRecoveredK4 {
     
    764782       
    765783        /// <summary>
    766         ///   Sucht eine lokalisierte Zeichenfolge, die Recovered subkey K5: ähnelt.
     784        ///   Sucht eine lokalisierte Zeichenfolge, die Restored round key K5: ähnelt.
    767785        /// </summary>
    768786        internal static string SummaryResultViewRecoveredK5 {
     
    782800       
    783801        /// <summary>
    784         ///   Sucht eine lokalisierte Zeichenfolge, die Tried keys: ähnelt.
     802        ///   Sucht eine lokalisierte Zeichenfolge, die Tested keys: ähnelt.
    785803        /// </summary>
    786804        internal static string SummaryResultViewTestedKeys {
     
    809827       
    810828        /// <summary>
    811         ///   Sucht eine lokalisierte Zeichenfolge, die Full status ähnelt.
     829        ///   Sucht eine lokalisierte Zeichenfolge, die Overall status ähnelt.
    812830        /// </summary>
    813831        internal static string TabItemHeaderSummary {
     
    818836       
    819837        /// <summary>
    820         ///   Sucht eine lokalisierte Zeichenfolge, die Usable threads ähnelt.
     838        ///   Sucht eine lokalisierte Zeichenfolge, die Threads to be used ähnelt.
    821839        /// </summary>
    822840        internal static string ThreadCount {
     
    872890       
    873891        /// <summary>
    874         ///   Sucht eine lokalisierte Zeichenfolge, die Plaintext-pairs ähnelt.
     892        ///   Sucht eine lokalisierte Zeichenfolge, die Plaintext message pairs ähnelt.
    875893        /// </summary>
    876894        internal static string UnencryptedMessagePairsInput {
     
    881899       
    882900        /// <summary>
    883         ///   Sucht eine lokalisierte Zeichenfolge, die Input for the plaintext-pairs ähnelt.
     901        ///   Sucht eine lokalisierte Zeichenfolge, die Input for the plaintext message pairs ähnelt.
    884902        /// </summary>
    885903        internal static string UnencryptedMessagePairsInputToolTip {
  • trunk/CrypPlugins/DCAKeyRecovery/Properties/Resources.de.resx

    r8412 r8416  
    248248  </data>
    249249  <data name="FinishedOutputToolTip" xml:space="preserve">
    250     <value>Der Ausgang zeigt der PfadFinder-Komponente an, dass die Berechnung abgeschlossen ist</value>
     250    <value>Der Ausgang zeigt der DKA-PfadFinder-Komponente an, dass die Berechnung abgeschlossen ist</value>
    251251  </data>
    252252  <data name="Lang" xml:space="preserve">
     
    302302  </data>
    303303  <data name="MessageNoResult" xml:space="preserve">
    304     <value>Die letzten Rundenschlüssel konnten nicht wiederhergestellt werden. Das kann passieren, wenn einer der vorigen Rundenschlüssel falsch berechnet wurde. Möglicherweise sollten die Parameter in der PfadFinder-Komponente neu gewählt werden.</value>
     304    <value>Die letzten Rundenschlüssel konnten nicht wiederhergestellt werden. Das kann passieren, wenn einer der vorigen Rundenschlüssel falsch berechnet wurde. Möglicherweise sollten die Parameter in der DKA-PfadFinder-Komponente neu gewählt werden.</value>
    305305  </data>
    306306  <data name="NeededMessageCountOutput" xml:space="preserve">
     
    314314  </data>
    315315  <data name="nextStepTextRun2" xml:space="preserve">
    316     <value>PfadFinder-Komponente fortgesetzt</value>
     316    <value>DKA-PfadFinder-Komponente fortgesetzt</value>
    317317  </data>
    318318  <data name="PerformanceSettingsGroup" xml:space="preserve">
  • trunk/CrypPlugins/DCAKeyRecovery/Properties/Resources.resx

    r8364 r8416  
    119119  </resheader>
    120120  <data name="AnyRoundAttackDataColHeader1" xml:space="preserve">
    121     <value>Key candidate</value>
     121    <value>key candidate</value>
    122122  </data>
    123123  <data name="AnyRoundAttackDataColHeader2" xml:space="preserve">
    124     <value>Hitcount</value>
     124    <value>Number of hits</value>
    125125  </data>
    126126  <data name="AnyRoundAttackDataColHeader3" xml:space="preserve">
     
    143143  </data>
    144144  <data name="AnyRoundExpectedHitCount" xml:space="preserve">
    145     <value>Expected hitcount:</value>
     145    <value>Expected number of hits:</value>
    146146  </data>
    147147  <data name="AnyRoundExpectedProbability" xml:space="preserve">
     
    149149  </data>
    150150  <data name="AnyRoundMessagePairCount" xml:space="preserve">
    151     <value>Count of Messagepairs:</value>
     151    <value>Count of message pairs:</value>
    152152  </data>
    153153  <data name="AnyRoundRecoveredRoundKey" xml:space="preserve">
    154     <value>Recovered roundkey:</value>
     154    <value>Recovered round key:</value>
    155155  </data>
    156156  <data name="AttackLastRoundHeader" xml:space="preserve">
    157     <value>{0} key restore</value>
     157    <value>{0} key recovery</value>
    158158  </data>
    159159  <data name="AutomaticMode" xml:space="preserve">
     
    176176  </data>
    177177  <data name="ChoiceOfAlgorithm" xml:space="preserve">
    178     <value>Cipher selection</value>
     178    <value>Choice of cipher</value>
    179179  </data>
    180180  <data name="ChoiceOfAlgorithmToolTop" xml:space="preserve">
    181     <value>At this point one of the ciphers contained in the list can be selected. This cipher can be examined by differential cryptanalysis.</value>
     181    <value>At this point, you can select one of the ciphers contained in the list. This can be examined by differential cryptanalysis.</value>
    182182  </data>
    183183  <data name="Cipher1" xml:space="preserve">
    184     <value>Cipher 1 (16 bit blocksize, 2 subkeys, keylength is 32 bit)</value>
     184    <value>Cipher 1 (16 bit block size, 2 round keys, 32 bit key length)</value>
    185185  </data>
    186186  <data name="Cipher1CipherViewCol" xml:space="preserve">
    187     <value>Key candidate</value>
    188   </data>
    189   <data name="Cipher1SummaryResultViewTotalSummary1" xml:space="preserve">
     187    <value>key candidate</value>
     188  </data>
     189  <data name="Cipher1SummaryResultViewTotalSummary" xml:space="preserve">
    190190    <value>Total</value>
    191191  </data>
    192192  <data name="Cipher2" xml:space="preserve">
    193     <value>Cipher 2 (16 bit blocksize, 4 subkeys, keylength is 64 bit)</value>
     193    <value>Cipher 2 (16 bit block size, 4 round keys, 64 bit key length)</value>
    194194  </data>
    195195  <data name="Cipher2SummaryResultViewRound1" xml:space="preserve">
     
    206206  </data>
    207207  <data name="Cipher3" xml:space="preserve">
    208     <value>Cipher 3 (16 bit blocksize, 6 subkeys, keylength is 96 bit)</value>
     208    <value>Cipher 3 (16 bit block size, 6 round keys, 96 bit key length)</value>
    209209  </data>
    210210  <data name="Cipher3SummaryResultViewRound1" xml:space="preserve">
     
    233233  </data>
    234234  <data name="EncryptedMessagePairsInput" xml:space="preserve">
    235     <value>Ciphertext-pairs</value>
     235    <value>ciphertext message pairs</value>
    236236  </data>
    237237  <data name="EncryptedMessagePairsInputToolTip" xml:space="preserve">
    238     <value>Input for the ciphertext-pairs</value>
     238    <value>Input for the ciphertext message pairs</value>
     239  </data>
     240  <data name="ExpectedDifferential" xml:space="preserve">
     241    <value>Expected difference</value>
     242  </data>
     243  <data name="ExpectedDifferentialToolTip" xml:space="preserve">
     244    <value>Output for the expected difference</value>
    239245  </data>
    240246  <data name="FinishedOutput" xml:space="preserve">
     
    242248  </data>
    243249  <data name="FinishedOutputToolTip" xml:space="preserve">
    244     <value>The output indicates to the PathFinder component that the calculation has been completed</value>
     250    <value>The output indicates to the DCA PathFinder component that the calculation has been completed.</value>
    245251  </data>
    246252  <data name="Lang" xml:space="preserve">
    247     <value>ENG</value>
     253    <value>GER</value>
    248254  </data>
    249255  <data name="LastRoundAttackCurrentCiphertext" xml:space="preserve">
     
    254260  </data>
    255261  <data name="LastRoundAttackCurrentKeyOfAll" xml:space="preserve">
    256     <value>Number of keys to test:</value>
     262    <value>Number of keys to be tested:</value>
    257263  </data>
    258264  <data name="LastRoundAttackCurrentPlaintext" xml:space="preserve">
     
    272278  </data>
    273279  <data name="LastRoundAttackNumberOfExaminedPairs" xml:space="preserve">
    274     <value>Examined plaintext/keytext pairs:</value>
     280    <value>Examined plaintext/ciphertext pairs:</value>
    275281  </data>
    276282  <data name="LastRoundAttackRemainingKeyCandidates" xml:space="preserve">
     
    278284  </data>
    279285  <data name="LastRoundAttackRound" xml:space="preserve">
    280     <value>Attacked round:</value>
     286    <value>Attacked encryption round:</value>
    281287  </data>
    282288  <data name="LastRoundAttackRoundResults" xml:space="preserve">
     
    290296  </data>
    291297  <data name="MessageDifferenceOutput" xml:space="preserve">
    292     <value>Expected difference</value>
     298    <value>Expected difference:</value>
    293299  </data>
    294300  <data name="MessageDifferenceOutputToolTip" xml:space="preserve">
     
    296302  </data>
    297303  <data name="MessageNoResult" xml:space="preserve">
    298     <value>The last subkeys could not be restored. This can happen if one of the previous subkeys was incorrectly calculated. Possibly the parameters in the PathFinder component should be selected again.</value>
     304    <value>The last round keys could not be restored. This can happen if one of the previous round keys was incorrectly calculated. Possibly the parameters in the DCA PathFinder component should be selected again.</value>
    299305  </data>
    300306  <data name="NeededMessageCountOutput" xml:space="preserve">
    301     <value>Message pair count</value>
     307    <value>Number of message pairs</value>
    302308  </data>
    303309  <data name="NeededMessageCountOutputToolTip" xml:space="preserve">
    304     <value>Input for the message pair count</value>
     310    <value>Output for the number of requested message pairs</value>
    305311  </data>
    306312  <data name="nextStepTextRun1" xml:space="preserve">
    307     <value>The differential cryptanalysis has to be</value>
     313    <value>Differential cryptanalysis is continued in the</value>
    308314  </data>
    309315  <data name="nextStepTextRun2" xml:space="preserve">
    310     <value>continued in the PathFinder component</value>
     316    <value>DCA PathFinder componend</value>
    311317  </data>
    312318  <data name="PerformanceSettingsGroup" xml:space="preserve">
    313     <value>Speed settings</value>
     319    <value>speed options</value>
    314320  </data>
    315321  <data name="PluginCaption" xml:space="preserve">
     
    317323  </data>
    318324  <data name="PluginTooltip" xml:space="preserve">
    319     <value>This component performs recovery of key bits from round keys.</value>
     325    <value>This component performs the recovery of key bits from round keys.</value>
    320326  </data>
    321327  <data name="RoundKeysOutput" xml:space="preserve">
    322     <value>Roundkeys</value>
     328    <value>Round keys</value>
    323329  </data>
    324330  <data name="RoundKeysOutputToolTip" xml:space="preserve">
    325     <value>Output for the roundkeys</value>
     331    <value>Output of the round keys</value>
    326332  </data>
    327333  <data name="SummaryResultViewCountOfDecryptions" xml:space="preserve">
    328     <value>Decryption count:</value>
     334    <value>Number of decryptions:</value>
    329335  </data>
    330336  <data name="SummaryResultViewCountOfMessages" xml:space="preserve">
    331     <value>Message count:</value>
     337    <value>Number of messages:</value>
    332338  </data>
    333339  <data name="SummaryResultViewCurrentRound" xml:space="preserve">
     
    338344  </data>
    339345  <data name="SummaryResultViewRecoveredK0" xml:space="preserve">
    340     <value>Recovered subkey K0:</value>
     346    <value>Restored round key K0:</value>
    341347  </data>
    342348  <data name="SummaryResultViewRecoveredK1" xml:space="preserve">
    343     <value>Recovered subkey K1:</value>
     349    <value>Restored round key K1:</value>
    344350  </data>
    345351  <data name="SummaryResultViewRecoveredK2" xml:space="preserve">
    346     <value>Recovered subkey K2:</value>
     352    <value>Restored round key K2:</value>
    347353  </data>
    348354  <data name="SummaryResultViewRecoveredK3" xml:space="preserve">
    349     <value>Recovered subkey K3:</value>
     355    <value>Restored round key K3:</value>
    350356  </data>
    351357  <data name="SummaryResultViewRecoveredK4" xml:space="preserve">
    352     <value>Recovered subkey K4:</value>
     358    <value>Restored round key K4:</value>
    353359  </data>
    354360  <data name="SummaryResultViewRecoveredK5" xml:space="preserve">
    355     <value>Recovered subkey K5:</value>
     361    <value>Restored round key K5:</value>
    356362  </data>
    357363  <data name="SummaryResultViewStartTime" xml:space="preserve">
     
    359365  </data>
    360366  <data name="SummaryResultViewTestedKeys" xml:space="preserve">
    361     <value>Tried keys:</value>
     367    <value>Tested keys:</value>
    362368  </data>
    363369  <data name="TabItemHeaderCipher" xml:space="preserve">
     
    368374  </data>
    369375  <data name="TabItemHeaderSummary" xml:space="preserve">
    370     <value>Full status</value>
     376    <value>Overall status</value>
    371377  </data>
    372378  <data name="ThreadCount" xml:space="preserve">
    373     <value>Usable threads</value>
     379    <value>Threads to be used</value>
    374380  </data>
    375381  <data name="ThreadCountToolTip" xml:space="preserve">
     
    389395  </data>
    390396  <data name="UnencryptedMessagePairsInput" xml:space="preserve">
    391     <value>Plaintext-pairs</value>
     397    <value>Plaintext message pairs</value>
    392398  </data>
    393399  <data name="UnencryptedMessagePairsInputToolTip" xml:space="preserve">
    394     <value>Input for the plaintext-pairs</value>
     400    <value>Input for the plaintext message pairs</value>
    395401  </data>
    396402</root>
  • trunk/CrypPlugins/DCAOracle/Properties/Resources.Designer.cs

    r8415 r8416  
    134134       
    135135        /// <summary>
    136         ///   Sucht eine lokalisierte Zeichenfolge, die The count of message pairs must be greater than 0! ähnelt.
     136        ///   Sucht eine lokalisierte Zeichenfolge, die The number of message pairs must be greater than 0! ähnelt.
    137137        /// </summary>
    138138        internal static string WarningMessageCountMustBeSpecified {
  • trunk/CrypPlugins/DCAOracle/Properties/Resources.resx

    r8415 r8416  
    143143  </data>
    144144  <data name="WarningMessageCountMustBeSpecified" xml:space="preserve">
    145     <value>The count of message pairs must be greater than 0!</value>
     145    <value>The number of message pairs must be greater than 0!</value>
    146146  </data>
    147147  <data name="WorSizeParameter" xml:space="preserve">
  • trunk/CrypPlugins/DCAPathFinder/DCAPathFinder.cs

    r8381 r8416  
    529529
    530530                                //check if there is a result
    531                                 if (conf.Characteristics.Count == 0)
     531                                if (conf != null && conf.Characteristics.Count == 0)
    532532                                {
    533533                                    GuiLogMessage(Resources.NoCharacteristicFoundError, NotificationLevel.Warning);
     
    692692
    693693                                //check if there is a result
    694                                 if (conf.Characteristics.Count == 0)
     694                                if (conf != null && conf.Characteristics.Count == 0)
    695695                                {
    696696                                    GuiLogMessage(Resources.NoCharacteristicFoundError, NotificationLevel.Warning);
     
    15111511
    15121512                                //check if there is a result
    1513                                 if (conf.Characteristics.Count == 0)
     1513                                if (conf != null && conf.Characteristics.Count == 0)
    15141514                                {
    15151515                                    GuiLogMessage(Resources.NoCharacteristicFoundError, NotificationLevel.Warning);
     
    16701670
    16711671                                //check if there is a result
    1672                                 if (conf.Characteristics.Count == 0)
     1672                                if (conf != null && conf.Characteristics.Count == 0)
    16731673                                {
    16741674                                    GuiLogMessage(Resources.NoCharacteristicFoundError, NotificationLevel.Warning);
     
    18281828
    18291829                                //check if there is a result
    1830                                 if (conf.Characteristics.Count == 0)
     1830                                if (conf != null && conf.Characteristics.Count == 0)
    18311831                                {
    18321832                                    GuiLogMessage(Resources.NoCharacteristicFoundError, NotificationLevel.Warning);
     
    19851985
    19861986                                //check if there is a result
    1987                                 if (conf.Characteristics.Count == 0)
     1987                                if (conf != null && conf.Characteristics.Count == 0)
    19881988                                {
    19891989                                    GuiLogMessage(Resources.NoCharacteristicFoundError, NotificationLevel.Warning);
  • trunk/CrypPlugins/DCAPathFinder/Properties/Resources.Designer.cs

    r8381 r8416  
    6262       
    6363        /// <summary>
    64         ///   Sucht eine lokalisierte Zeichenfolge, die Probability (differential) ähnelt.
     64        ///   Sucht eine lokalisierte Zeichenfolge, die Global maximum ähnelt.
     65        /// </summary>
     66        public static string AbortingPolicy1 {
     67            get {
     68                return ResourceManager.GetString("AbortingPolicy1", resourceCulture);
     69            }
     70        }
     71       
     72        /// <summary>
     73        ///   Sucht eine lokalisierte Zeichenfolge, die Global threshold ähnelt.
     74        /// </summary>
     75        public static string AbortingPolicy2 {
     76            get {
     77                return ResourceManager.GetString("AbortingPolicy2", resourceCulture);
     78            }
     79        }
     80       
     81        /// <summary>
     82        ///   Sucht eine lokalisierte Zeichenfolge, die Threshold value for abort (best characteristic) ähnelt.
     83        /// </summary>
     84        public static string AbortingThresholdBestCharacteristicSearch {
     85            get {
     86                return ResourceManager.GetString("AbortingThresholdBestCharacteristicSearch", resourceCulture);
     87            }
     88        }
     89       
     90        /// <summary>
     91        ///   Sucht eine lokalisierte Zeichenfolge, die Determines the probability at which the search for the best characteristic will be aborted. ähnelt.
     92        /// </summary>
     93        public static string AbortingThresholdBestCharacteristicSearchToolTip {
     94            get {
     95                return ResourceManager.GetString("AbortingThresholdBestCharacteristicSearchToolTip", resourceCulture);
     96            }
     97        }
     98       
     99        /// <summary>
     100        ///   Sucht eine lokalisierte Zeichenfolge, die Threshold value for abort (differential) ähnelt.
    65101        /// </summary>
    66102        public static string AbortingThresholdDifferentialSearch {
     
    71107       
    72108        /// <summary>
    73         ///   Sucht eine lokalisierte Zeichenfolge, die Defines the probability at which the search for characteristics for a differential is aborted ähnelt.
     109        ///   Sucht eine lokalisierte Zeichenfolge, die Determines the probability at which the search for characteristics for differential formation is aborted. ähnelt.
    74110        /// </summary>
    75111        public static string AbortingThresholdDifferentialSearchToolTip {
     
    89125       
    90126        /// <summary>
    91         ///   Sucht eine lokalisierte Zeichenfolge, die PathFinder running in the automatic mode. ähnelt.
     127        ///   Sucht eine lokalisierte Zeichenfolge, die DCA PfadFinder works in automatic mode. ähnelt.
    92128        /// </summary>
    93129        public static string AutomaticModeHeader {
     
    107143       
    108144        /// <summary>
     145        ///   Sucht eine lokalisierte Zeichenfolge, die Chapter back ähnelt.
     146        /// </summary>
     147        public static string BtnPrevChapter {
     148            get {
     149                return ResourceManager.GetString("BtnPrevChapter", resourceCulture);
     150            }
     151        }
     152       
     153        /// <summary>
    109154        ///   Sucht eine lokalisierte Zeichenfolge, die Skip chapter ähnelt.
    110155        /// </summary>
     
    125170       
    126171        /// <summary>
    127         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher selection ähnelt.
     172        ///   Sucht eine lokalisierte Zeichenfolge, die Aborting policy ähnelt.
     173        /// </summary>
     174        public static string ChoiceAbortingPolicyPolicy {
     175            get {
     176                return ResourceManager.GetString("ChoiceAbortingPolicyPolicy", resourceCulture);
     177            }
     178        }
     179       
     180        /// <summary>
     181        ///   Sucht eine lokalisierte Zeichenfolge, die search options ähnelt.
     182        /// </summary>
     183        public static string ChoiceOfAbortingPolicyGroup {
     184            get {
     185                return ResourceManager.GetString("ChoiceOfAbortingPolicyGroup", resourceCulture);
     186            }
     187        }
     188       
     189        /// <summary>
     190        ///   Sucht eine lokalisierte Zeichenfolge, die By selecting the aborting policy, the behavior of the search for the best differential is controlled. ähnelt.
     191        /// </summary>
     192        public static string ChoiceOfAbortingPolicyToolTop {
     193            get {
     194                return ResourceManager.GetString("ChoiceOfAbortingPolicyToolTop", resourceCulture);
     195            }
     196        }
     197       
     198        /// <summary>
     199        ///   Sucht eine lokalisierte Zeichenfolge, die Choice of the cipher ähnelt.
    128200        /// </summary>
    129201        public static string ChoiceOfAlgorithm {
     
    143215       
    144216        /// <summary>
    145         ///   Sucht eine lokalisierte Zeichenfolge, die At this point one of the ciphers contained in the list can be selected. This cipher can be examined by differential cryptanalysis. ähnelt.
     217        ///   Sucht eine lokalisierte Zeichenfolge, die At this point, you can select one of the ciphers contained in the list. This can be examined by differential cryptanalysis. ähnelt.
    146218        /// </summary>
    147219        public static string ChoiceOfAlgorithmToolTop {
     
    152224       
    153225        /// <summary>
    154         ///   Sucht eine lokalisierte Zeichenfolge, die Search strategy ähnelt.
     226        ///   Sucht eine lokalisierte Zeichenfolge, die Search policy ähnelt.
    155227        /// </summary>
    156228        public static string ChoiceOfSearchPolicy {
     
    170242       
    171243        /// <summary>
    172         ///   Sucht eine lokalisierte Zeichenfolge, die By selecting a search strategy, the behavior of the search for the best differential is controlled ähnelt.
     244        ///   Sucht eine lokalisierte Zeichenfolge, die By selecting a search policy, the behavior of the search for the best differential is controlled. ähnelt.
    173245        /// </summary>
    174246        public static string ChoiceOfSearchPolicyToolTop {
     
    188260       
    189261        /// <summary>
    190         ///   Sucht eine lokalisierte Zeichenfolge, die Determines the number of message pairs to be generated ähnelt.
     262        ///   Sucht eine lokalisierte Zeichenfolge, die Determines the number of message pairs to be generated. ähnelt.
    191263        /// </summary>
    192264        public static string ChosenMessagePairsCountToolTip {
     
    197269       
    198270        /// <summary>
    199         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 1: Cipher 1 (16 bit blocksize, 2 subkeys, keylength is 32 bit) ähnelt.
     271        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 1: Cipher 1 (16 bit block size, 2 round keys, 32 bit key length) ähnelt.
    200272        /// </summary>
    201273        public static string Cipher1 {
     
    206278       
    207279        /// <summary>
    208         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2: Cipher 2 (16 bit blocksize, 4 subkeys, keylength is 64 bit) ähnelt.
     280        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2: Cipher 2 (16 bit block size, 4 round keys, 64 bit key length) ähnelt.
    209281        /// </summary>
    210282        public static string Cipher2 {
     
    215287       
    216288        /// <summary>
    217         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 3: Cipher 3 (16 bit blocksize, 6 subkeys, keylength is 96 bit) ähnelt.
     289        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 3: Cipher 3 (16 bit block size, 6 round keys, 96 bit key length) ähnelt.
    218290        /// </summary>
    219291        public static string Cipher3 {
     
    224296       
    225297        /// <summary>
    226         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 4: Cipher 4 (4 bit blocksize, 4 subkeys, keylength is16 bit) ähnelt.
     298        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 4: Cipher 4 (4 bit block size , 4 round keys, 16 bit key length) ähnelt.
    227299        /// </summary>
    228300        public static string Cipher4 {
     
    233305       
    234306        /// <summary>
    235         ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis options ähnelt.
     307        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis Options ähnelt.
    236308        /// </summary>
    237309        public static string DCAOptions {
     
    242314       
    243315        /// <summary>
    244         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 1 uses cipher 1 of the ToyChiffren component. This cipher works on 16 bit blocks and uses two round keys. One encryption round is executed. In this tutorial two unknown 16 bit round keys are restored. ähnelt.
     316        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 1 uses cipher 1 of the DCA ToyCipher component. This cipher works on 16 bit blocks and uses two 16 bit round keys. One encryption round is executed. In this tutorial both unknown round keys are restored. ähnelt.
    245317        /// </summary>
    246318        public static string DescriptionContent2 {
     
    251323       
    252324        /// <summary>
    253         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2 uses cipher 2 of the ToyChiffren component. This cipher works on 16 bit blocks and uses four round keys. Three encryption rounds are executed. In this tutorial four unknown 16 bit roundkeys are restored. ähnelt.
     325        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2 uses cipher 2 of the DCA ToyCipher component. This cipher works on 16 bit blocks and uses four 16 bit round keys. Three encryption rounds are executed. In this tutorial all unknown round keys are restored. ähnelt.
    254326        /// </summary>
    255327        public static string DescriptionContent3 {
     
    260332       
    261333        /// <summary>
    262         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 3 uses cipher 3 of the ToyChiffren component. This cipher works on 16 bit blocks and uses six round keys. Five encryption rounds are executed. In this tutorial six unknown 16 bit round keys are restored. ähnelt.
     334        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 3 uses cipher 3 of the DKA ToyCipher component. This cipher works on 16 bit blocks and uses six 16 bit round keys. Five encryption rounds are executed. In this tutorial all unknown round keys are restored. ähnelt.
    263335        /// </summary>
    264336        public static string DescriptionContent4 {
     
    305377       
    306378        /// <summary>
    307         ///   Sucht eine lokalisierte Zeichenfolge, die Display options ähnelt.
     379        ///   Sucht eine lokalisierte Zeichenfolge, die display options ähnelt.
    308380        /// </summary>
    309381        public static string DisplayOptions {
     
    341413       
    342414        /// <summary>
    343         ///   Sucht eine lokalisierte Zeichenfolge, die Messagecount ähnelt.
     415        ///   Sucht eine lokalisierte Zeichenfolge, die Input difference ähnelt.
     416        /// </summary>
     417        public static string InputDiffHeader1 {
     418            get {
     419                return ResourceManager.GetString("InputDiffHeader1", resourceCulture);
     420            }
     421        }
     422       
     423        /// <summary>
     424        ///   Sucht eine lokalisierte Zeichenfolge, die u ähnelt.
     425        /// </summary>
     426        public static string InputDiffR1Header1Run1 {
     427            get {
     428                return ResourceManager.GetString("InputDiffR1Header1Run1", resourceCulture);
     429            }
     430        }
     431       
     432        /// <summary>
     433        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     434        /// </summary>
     435        public static string InputDiffR1Header1Run2 {
     436            get {
     437                return ResourceManager.GetString("InputDiffR1Header1Run2", resourceCulture);
     438            }
     439        }
     440       
     441        /// <summary>
     442        ///   Sucht eine lokalisierte Zeichenfolge, die u ähnelt.
     443        /// </summary>
     444        public static string InputDiffR2Header1Run1 {
     445            get {
     446                return ResourceManager.GetString("InputDiffR2Header1Run1", resourceCulture);
     447            }
     448        }
     449       
     450        /// <summary>
     451        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
     452        /// </summary>
     453        public static string InputDiffR2Header1Run2 {
     454            get {
     455                return ResourceManager.GetString("InputDiffR2Header1Run2", resourceCulture);
     456            }
     457        }
     458       
     459        /// <summary>
     460        ///   Sucht eine lokalisierte Zeichenfolge, die u ähnelt.
     461        /// </summary>
     462        public static string InputDiffR3Header1Run1 {
     463            get {
     464                return ResourceManager.GetString("InputDiffR3Header1Run1", resourceCulture);
     465            }
     466        }
     467       
     468        /// <summary>
     469        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     470        /// </summary>
     471        public static string InputDiffR3Header1Run2 {
     472            get {
     473                return ResourceManager.GetString("InputDiffR3Header1Run2", resourceCulture);
     474            }
     475        }
     476       
     477        /// <summary>
     478        ///   Sucht eine lokalisierte Zeichenfolge, die u ähnelt.
     479        /// </summary>
     480        public static string InputDiffR4Header1Run1 {
     481            get {
     482                return ResourceManager.GetString("InputDiffR4Header1Run1", resourceCulture);
     483            }
     484        }
     485       
     486        /// <summary>
     487        ///   Sucht eine lokalisierte Zeichenfolge, die 4 ähnelt.
     488        /// </summary>
     489        public static string InputDiffR4Header1Run2 {
     490            get {
     491                return ResourceManager.GetString("InputDiffR4Header1Run2", resourceCulture);
     492            }
     493        }
     494       
     495        /// <summary>
     496        ///   Sucht eine lokalisierte Zeichenfolge, die u ähnelt.
     497        /// </summary>
     498        public static string InputDiffR5Header1Run1 {
     499            get {
     500                return ResourceManager.GetString("InputDiffR5Header1Run1", resourceCulture);
     501            }
     502        }
     503       
     504        /// <summary>
     505        ///   Sucht eine lokalisierte Zeichenfolge, die 5 ähnelt.
     506        /// </summary>
     507        public static string InputDiffR5Header1Run2 {
     508            get {
     509                return ResourceManager.GetString("InputDiffR5Header1Run2", resourceCulture);
     510            }
     511        }
     512       
     513        /// <summary>
     514        ///   Sucht eine lokalisierte Zeichenfolge, die message pair count ähnelt.
    344515        /// </summary>
    345516        public static string MessageCount {
     
    350521       
    351522        /// <summary>
    352         ///   Sucht eine lokalisierte Zeichenfolge, die Output for the number of messages ähnelt.
     523        ///   Sucht eine lokalisierte Zeichenfolge, die Output for the message pair count ähnelt.
    353524        /// </summary>
    354525        public static string MessageCountToolTip {
     
    359530       
    360531        /// <summary>
    361         ///   Sucht eine lokalisierte Zeichenfolge, die No characteristics found. Please check the settings for the search and abort strategy. ähnelt.
     532        ///   Sucht eine lokalisierte Zeichenfolge, die No characteristics found. Please check the settings for the search and abort policy ähnelt.
    362533        /// </summary>
    363534        public static string NoCharacteristicFoundError {
     
    368539       
    369540        /// <summary>
    370         ///   Sucht eine lokalisierte Zeichenfolge, die Welcome to the differential cryptanalysis (DCA) tutorial. This method for the analysis of round-based symmetric block ciphers aims at recovering single bits up to complete round keys. This method was published in 1991 by the two Israeli researchers, Eli Biham and Adi Shamir. ähnelt.
     541        ///   Sucht eine lokalisierte Zeichenfolge, die v ähnelt.
     542        /// </summary>
     543        public static string OutputDiffR1Header1Run1 {
     544            get {
     545                return ResourceManager.GetString("OutputDiffR1Header1Run1", resourceCulture);
     546            }
     547        }
     548       
     549        /// <summary>
     550        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     551        /// </summary>
     552        public static string OutputDiffR1Header1Run2 {
     553            get {
     554                return ResourceManager.GetString("OutputDiffR1Header1Run2", resourceCulture);
     555            }
     556        }
     557       
     558        /// <summary>
     559        ///   Sucht eine lokalisierte Zeichenfolge, die v ähnelt.
     560        /// </summary>
     561        public static string OutputDiffR2Header1Run1 {
     562            get {
     563                return ResourceManager.GetString("OutputDiffR2Header1Run1", resourceCulture);
     564            }
     565        }
     566       
     567        /// <summary>
     568        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
     569        /// </summary>
     570        public static string OutputDiffR2Header1Run2 {
     571            get {
     572                return ResourceManager.GetString("OutputDiffR2Header1Run2", resourceCulture);
     573            }
     574        }
     575       
     576        /// <summary>
     577        ///   Sucht eine lokalisierte Zeichenfolge, die v ähnelt.
     578        /// </summary>
     579        public static string OutputDiffR3Header1Run1 {
     580            get {
     581                return ResourceManager.GetString("OutputDiffR3Header1Run1", resourceCulture);
     582            }
     583        }
     584       
     585        /// <summary>
     586        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     587        /// </summary>
     588        public static string OutputDiffR3Header1Run2 {
     589            get {
     590                return ResourceManager.GetString("OutputDiffR3Header1Run2", resourceCulture);
     591            }
     592        }
     593       
     594        /// <summary>
     595        ///   Sucht eine lokalisierte Zeichenfolge, die v ähnelt.
     596        /// </summary>
     597        public static string OutputDiffR4Header1Run1 {
     598            get {
     599                return ResourceManager.GetString("OutputDiffR4Header1Run1", resourceCulture);
     600            }
     601        }
     602       
     603        /// <summary>
     604        ///   Sucht eine lokalisierte Zeichenfolge, die 4 ähnelt.
     605        /// </summary>
     606        public static string OutputDiffR4Header1Run2 {
     607            get {
     608                return ResourceManager.GetString("OutputDiffR4Header1Run2", resourceCulture);
     609            }
     610        }
     611       
     612        /// <summary>
     613        ///   Sucht eine lokalisierte Zeichenfolge, die Welcome to the differential cryptanalysis (dca) tutorial. This method for the analysis of turn-based symmetric block ciphers aims at recovering single bits up to complete round keys. This procedure was published in 1991 by the two Israeli researchers Eli Biham and Adi Shamir. ähnelt.
    371614        /// </summary>
    372615        public static string OverviewContent1 {
     
    377620       
    378621        /// <summary>
    379         ///   Sucht eine lokalisierte Zeichenfolge, die This tutorial describes the differential cryptanalysis procedure in three parts. Part 1 explains the basic idea of DCA using a cipher with one encryption round. Part 2 deepens this idea using a cipher with three encryption rounds. Part three deepens the knowledge by increasing the complexity of the cipher to 5 encryption rounds. In part three the knowledge is deepened by increasing the complexity of the cipher to 5 encryption rounds. ähnelt.
     622        ///   Sucht eine lokalisierte Zeichenfolge, die This tutorial covers the dca in three parts. Part 1 conveys the basic idea of the dca by means of a cipher with an encryption round. Part 2 deepens this idea using a cipher with three encryption rounds. Part 3 deepens the knowledge by increasing the complexity of the cipher to five encryption rounds. ähnelt.
    380623        /// </summary>
    381624        public static string OverviewContent2 {
     
    386629       
    387630        /// <summary>
    388         ///   Sucht eine lokalisierte Zeichenfolge, die In the configuration of this component the different parts of the tutorial can be selected. ähnelt.
     631        ///   Sucht eine lokalisierte Zeichenfolge, die In the configuration of this component the number of the tutorial and the tutorial mode can be selected. ähnelt.
    389632        /// </summary>
    390633        public static string OverviewContent3 {
     
    440683       
    441684        /// <summary>
    442         ///   Sucht eine lokalisierte Zeichenfolge, die Describes the flow of the differential through a cipher ähnelt.
     685        ///   Sucht eine lokalisierte Zeichenfolge, die Describes the flow of differences through a cipher ähnelt.
    443686        /// </summary>
    444687        public static string PathToolTip {
     
    449692       
    450693        /// <summary>
    451         ///   Sucht eine lokalisierte Zeichenfolge, die Speed settings ähnelt.
     694        ///   Sucht eine lokalisierte Zeichenfolge, die Speed options ähnelt.
    452695        /// </summary>
    453696        public static string PerformanceSettingsGroup {
     
    485728       
    486729        /// <summary>
    487         ///   Sucht eine lokalisierte Zeichenfolge, die If tutorial mode is activated, a presentation with information on differential cryptanalysis is made for each tutorial ähnelt.
     730        ///   Sucht eine lokalisierte Zeichenfolge, die If tutorial mode is activated, a presentation with information on differential cryptanalysis is displayed for each tutorial. ähnelt.
    488731        /// </summary>
    489732        public static string PresentationModeToolTip {
     
    548791       
    549792        /// <summary>
    550         ///   Sucht eine lokalisierte Zeichenfolge, die Ready ähnelt.
     793        ///   Sucht eine lokalisierte Zeichenfolge, die Trigger ähnelt.
    551794        /// </summary>
    552795        public static string ReadyInput {
     
    557800       
    558801        /// <summary>
    559         ///   Sucht eine lokalisierte Zeichenfolge, die The ready input signals to the PathFinder component that the key recovery component has completed its calculation ähnelt.
     802        ///   Sucht eine lokalisierte Zeichenfolge, die The trigger input signals to the DCA PathFinder component that the DCA KeyRecovery component has completed its calculation. ähnelt.
    560803        /// </summary>
    561804        public static string ReadyInputToolTip {
     
    575818       
    576819        /// <summary>
    577         ///   Sucht eine lokalisierte Zeichenfolge, die Attacked SBoxes: ähnelt.
     820        ///   Sucht eine lokalisierte Zeichenfolge, die Attacked S boxes: ähnelt.
    578821        /// </summary>
    579822        public static string SBoxes {
     
    584827       
    585828        /// <summary>
    586         ///   Sucht eine lokalisierte Zeichenfolge, die At least one SBox must be marked to continue the attack. ähnelt.
     829        ///   Sucht eine lokalisierte Zeichenfolge, die At least one S box must be marked to continue the attack. ähnelt.
    587830        /// </summary>
    588831        public static string SBoxWarning {
     
    602845       
    603846        /// <summary>
    604         ///   Sucht eine lokalisierte Zeichenfolge, die Searchpolicy: ähnelt.
     847        ///   Sucht eine lokalisierte Zeichenfolge, die Search policy: ähnelt.
    605848        /// </summary>
    606849        public static string SearchPolicy {
     
    638881       
    639882        /// <summary>
    640         ///   Sucht eine lokalisierte Zeichenfolge, die Results ähnelt.
     883        ///   Sucht eine lokalisierte Zeichenfolge, die Result ähnelt.
    641884        /// </summary>
    642885        public static string SearchResults {
     
    647890       
    648891        /// <summary>
    649         ///   Sucht eine lokalisierte Zeichenfolge, die The tutorial starts when you start the workspace. ähnelt.
     892        ///   Sucht eine lokalisierte Zeichenfolge, die The tutorial beginns when you start the workspace. ähnelt.
    650893        /// </summary>
    651894        public static string StartMaskContent1 {
     
    656899       
    657900        /// <summary>
    658         ///   Sucht eine lokalisierte Zeichenfolge, die In this ähnelt.
     901        ///   Sucht eine lokalisierte Zeichenfolge, die In this template, the ähnelt.
    659902        /// </summary>
    660903        public static string StartMaskContent2Run1 {
     
    665908       
    666909        /// <summary>
    667         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial {0} ähnelt.
     910        ///   Sucht eine lokalisierte Zeichenfolge, die tutorial {0} ähnelt.
    668911        /// </summary>
    669912        public static string StartMaskContent2Run2 {
     
    701944       
    702945        /// <summary>
    703         ///   Sucht eine lokalisierte Zeichenfolge, die Usable threads ähnelt.
     946        ///   Sucht eine lokalisierte Zeichenfolge, die Threads to be used ähnelt.
    704947        /// </summary>
    705948        public static string ThreadCount {
     
    728971       
    729972        /// <summary>
    730         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial differential cryptanalysis of symmetric block ciphers ähnelt.
    731         /// </summary>
    732         public static string TitleHeader {
    733             get {
    734                 return ResourceManager.GetString("TitleHeader", resourceCulture);
    735             }
    736         }
    737        
    738         /// <summary>
    739973        ///   Sucht eine lokalisierte Zeichenfolge, die 2. Differential cryptanalysis of cipher 1 ähnelt.
    740974        /// </summary>
     
    755989       
    756990        /// <summary>
    757         ///   Sucht eine lokalisierte Zeichenfolge, die is already known. The cryptoanalyst now tries all values t of k ähnelt.
     991        ///   Sucht eine lokalisierte Zeichenfolge, die is already known. As indicated on the previous page, the values of k ähnelt.
    758992        /// </summary>
    759993        public static string Tutorial1DifferentialCryptanalysisSlide10Content2Run1 {
     
    7731007       
    7741008        /// <summary>
    775         ///   Sucht eine lokalisierte Zeichenfolge, die and every time ähnelt.
     1009        ///   Sucht eine lokalisierte Zeichenfolge, die  guessed. Here is explained how to limit the set of possible correct values: The cryptanalyst tries all values t of k ähnelt.
    7761010        /// </summary>
    7771011        public static string Tutorial1DifferentialCryptanalysisSlide10Content2Run3 {
     
    7821016       
    7831017        /// <summary>
    784         ///   Sucht eine lokalisierte Zeichenfolge, die is valid, t is noted as a candidate for k ähnelt.
     1018        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1019        /// </summary>
     1020        public static string Tutorial1DifferentialCryptanalysisSlide10Content2Run4 {
     1021            get {
     1022                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content2Run4", resourceCulture);
     1023            }
     1024        }
     1025       
     1026        /// <summary>
     1027        ///   Sucht eine lokalisierte Zeichenfolge, die  through and if ähnelt.
     1028        /// </summary>
     1029        public static string Tutorial1DifferentialCryptanalysisSlide10Content2Run5 {
     1030            get {
     1031                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content2Run5", resourceCulture);
     1032            }
     1033        }
     1034       
     1035        /// <summary>
     1036        ///   Sucht eine lokalisierte Zeichenfolge, die holds true, t is considered a candidate for k ähnelt.
    7851037        /// </summary>
    7861038        public static string Tutorial1DifferentialCryptanalysisSlide10Content3Run1 {
     
    8001052       
    8011053        /// <summary>
    802         ///   Sucht eine lokalisierte Zeichenfolge, die . If more than one candidate remains at the end, the attack will be reshuffled with new pairs of plaintext and ciphertext. ähnelt.
     1054        ///   Sucht eine lokalisierte Zeichenfolge, die . If more than one candidate remains at the end, the attack is repeated with new pairs of plaintext and ciphertext. ähnelt.
    8031055        /// </summary>
    8041056        public static string Tutorial1DifferentialCryptanalysisSlide10Content3Run3 {
     
    8091061       
    8101062        /// <summary>
    811         ///   Sucht eine lokalisierte Zeichenfolge, die By clicking the &quot;next&quot; button again, differential cryptanalysis can be performed on cipher 1 in the &quot;Key Recovery&quot; component. ähnelt.
     1063        ///   Sucht eine lokalisierte Zeichenfolge, die By clicking the &quot;Next&quot; button again, differential cryptanalysis can be performed on cipher 1 in the &quot;DCA KeyRecovery&quot; component. ähnelt.
    8121064        /// </summary>
    8131065        public static string Tutorial1DifferentialCryptanalysisSlide10Content4 {
     
    8181070       
    8191071        /// <summary>
     1072        ///   Sucht eine lokalisierte Zeichenfolge, die After successful recovery of k ähnelt.
     1073        /// </summary>
     1074        public static string Tutorial1DifferentialCryptanalysisSlide10Content4Run1 {
     1075            get {
     1076                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content4Run1", resourceCulture);
     1077            }
     1078        }
     1079       
     1080        /// <summary>
     1081        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1082        /// </summary>
     1083        public static string Tutorial1DifferentialCryptanalysisSlide10Content4Run2 {
     1084            get {
     1085                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content4Run2", resourceCulture);
     1086            }
     1087        }
     1088       
     1089        /// <summary>
     1090        ///   Sucht eine lokalisierte Zeichenfolge, die  can k ähnelt.
     1091        /// </summary>
     1092        public static string Tutorial1DifferentialCryptanalysisSlide10Content4Run3 {
     1093            get {
     1094                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content4Run3", resourceCulture);
     1095            }
     1096        }
     1097       
     1098        /// <summary>
     1099        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     1100        /// </summary>
     1101        public static string Tutorial1DifferentialCryptanalysisSlide10Content4Run4 {
     1102            get {
     1103                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content4Run4", resourceCulture);
     1104            }
     1105        }
     1106       
     1107        /// <summary>
     1108        ///   Sucht eine lokalisierte Zeichenfolge, die  be calculated immediately. This can be done by calculating the equation ähnelt.
     1109        /// </summary>
     1110        public static string Tutorial1DifferentialCryptanalysisSlide10Content4Run5 {
     1111            get {
     1112                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content4Run5", resourceCulture);
     1113            }
     1114        }
     1115       
     1116        /// <summary>
     1117        ///   Sucht eine lokalisierte Zeichenfolge, die be determined. ähnelt.
     1118        /// </summary>
     1119        public static string Tutorial1DifferentialCryptanalysisSlide10Content5Run1 {
     1120            get {
     1121                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide10Content5Run1", resourceCulture);
     1122            }
     1123        }
     1124       
     1125        /// <summary>
    8201126        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
    8211127        /// </summary>
     
    8271133       
    8281134        /// <summary>
    829         ///   Sucht eine lokalisierte Zeichenfolge, die At this point we apply the idea of differential cryptanalysis to cipher 1. The structure of a cipher is usually public, so that all components and their functionality are known. The security of a cipher should never be based on the secrecy of the construction, but on the secrecy of the key. This requirement is also called Kerckhoffs&apos; principle. ähnelt.
     1135        ///   Sucht eine lokalisierte Zeichenfolge, die Here we apply the idea of the dca to Chiffre 1. The structure of a cipher is usually public, so that all components and their functionality are known. The security of a cipher should never be based on the secrecy of the construction, but on the secrecy of the key. This requirement is also called Kerckhoff&apos;s principle. ähnelt.
    8301136        /// </summary>
    8311137        public static string Tutorial1DifferentialCryptanalysisSlide1Content1 {
     
    8361142       
    8371143        /// <summary>
    838         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 1 consists of key addition and substitution. The structure can be viewed in the ToyCipher component. We now try to restore the two unknown round keys k ähnelt.
     1144        ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 1 ähnelt.
    8391145        /// </summary>
    8401146        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run1 {
     
    8451151       
    8461152        /// <summary>
     1153        ///   Sucht eine lokalisierte Zeichenfolge, die  consists of key addition and substitution. The structure can be viewed in the DCA ToyCipher component. We now try to find the two unknown round keys k ähnelt.
     1154        /// </summary>
     1155        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run2 {
     1156            get {
     1157                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run2", resourceCulture);
     1158            }
     1159        }
     1160       
     1161        /// <summary>
    8471162        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
    8481163        /// </summary>
    849         public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run2 {
    850             get {
    851                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run2", resourceCulture);
     1164        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run3 {
     1165            get {
     1166                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run3", resourceCulture);
    8521167            }
    8531168        }
     
    8561171        ///   Sucht eine lokalisierte Zeichenfolge, die and k ähnelt.
    8571172        /// </summary>
    858         public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run3 {
    859             get {
    860                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run3", resourceCulture);
     1173        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run4 {
     1174            get {
     1175                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run4", resourceCulture);
    8611176            }
    8621177        }
     
    8651180        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    8661181        /// </summary>
    867         public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run4 {
    868             get {
    869                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run4", resourceCulture);
    870             }
    871         }
    872        
    873         /// <summary>
    874         ///   Sucht eine lokalisierte Zeichenfolge, die . To do this, we first look at the individual steps of the encryption. First, a key addition to the input block is performed with k ähnelt.
    875         /// </summary>
    8761182        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run5 {
    8771183            get {
     
    8811187       
    8821188        /// <summary>
     1189        ///   Sucht eine lokalisierte Zeichenfolge, die  to recover. To do this, we look at the individual steps of encryption. First the key k ähnelt.
     1190        /// </summary>
     1191        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run6 {
     1192            get {
     1193                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run6", resourceCulture);
     1194            }
     1195        }
     1196       
     1197        /// <summary>
    8831198        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
    8841199        /// </summary>
    885         public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run6 {
    886             get {
    887                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run6", resourceCulture);
    888             }
    889         }
    890        
    891         /// <summary>
    892         ///   Sucht eine lokalisierte Zeichenfolge, die . We get: ähnelt.
    893         /// </summary>
    8941200        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run7 {
    8951201            get {
     
    8991205       
    9001206        /// <summary>
    901         ///   Sucht eine lokalisierte Zeichenfolge, die Subsequently, a substitution by the SBoxes takes place: ähnelt.
     1207        ///   Sucht eine lokalisierte Zeichenfolge, die  is added to the input block m: ähnelt.
     1208        /// </summary>
     1209        public static string Tutorial1DifferentialCryptanalysisSlide1Content2Run8 {
     1210            get {
     1211                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide1Content2Run8", resourceCulture);
     1212            }
     1213        }
     1214       
     1215        /// <summary>
     1216        ///   Sucht eine lokalisierte Zeichenfolge, die The intermediate result u is then substituted by the S boxes: ähnelt.
    9021217        /// </summary>
    9031218        public static string Tutorial1DifferentialCryptanalysisSlide1Content3 {
     
    9171232       
    9181233        /// <summary>
    919         ///   Sucht eine lokalisierte Zeichenfolge, die Finally, a key addition with k ähnelt.
     1234        ///   Sucht eine lokalisierte Zeichenfolge, die Finally, a key addition takes place again (intermediate result v is indicated with k ähnelt.
    9201235        /// </summary>
    9211236        public static string Tutorial1DifferentialCryptanalysisSlide2Content1Run1 {
     
    9351250       
    9361251        /// <summary>
    937         ///   Sucht eine lokalisierte Zeichenfolge, die  takes place again: ähnelt.
     1252        ///   Sucht eine lokalisierte Zeichenfolge, die  added): ähnelt.
    9381253        /// </summary>
    9391254        public static string Tutorial1DifferentialCryptanalysisSlide2Content1Run3 {
     
    9441259       
    9451260        /// <summary>
     1261        ///   Sucht eine lokalisierte Zeichenfolge, die The internal variables u and v of the cipher are of great importance in the following, because we use these intermediate results to recover the unknown keys k ähnelt.
     1262        /// </summary>
     1263        public static string Tutorial1DifferentialCryptanalysisSlide2Content2Run1 {
     1264            get {
     1265                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide2Content2Run1", resourceCulture);
     1266            }
     1267        }
     1268       
     1269        /// <summary>
     1270        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1271        /// </summary>
     1272        public static string Tutorial1DifferentialCryptanalysisSlide2Content2Run2 {
     1273            get {
     1274                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide2Content2Run2", resourceCulture);
     1275            }
     1276        }
     1277       
     1278        /// <summary>
     1279        ///   Sucht eine lokalisierte Zeichenfolge, die  and k ähnelt.
     1280        /// </summary>
     1281        public static string Tutorial1DifferentialCryptanalysisSlide2Content2Run3 {
     1282            get {
     1283                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide2Content2Run3", resourceCulture);
     1284            }
     1285        }
     1286       
     1287        /// <summary>
     1288        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     1289        /// </summary>
     1290        public static string Tutorial1DifferentialCryptanalysisSlide2Content2Run4 {
     1291            get {
     1292                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide2Content2Run4", resourceCulture);
     1293            }
     1294        }
     1295       
     1296        /// <summary>
     1297        ///   Sucht eine lokalisierte Zeichenfolge, die . ähnelt.
     1298        /// </summary>
     1299        public static string Tutorial1DifferentialCryptanalysisSlide2Content2Run5 {
     1300            get {
     1301                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide2Content2Run5", resourceCulture);
     1302            }
     1303        }
     1304       
     1305        /// <summary>
    9461306        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
    9471307        /// </summary>
     
    9531313       
    9541314        /// <summary>
    955         ///   Sucht eine lokalisierte Zeichenfolge, die The following figure summarizes the encryption process as outlined above: ähnelt.
     1315        ///   Sucht eine lokalisierte Zeichenfolge, die The following figure summarizes the encryption process outlined above on slides 11 to 16. ähnelt.
    9561316        /// </summary>
    9571317        public static string Tutorial1DifferentialCryptanalysisSlide3Content1 {
     
    9711331       
    9721332        /// <summary>
    973         ///   Sucht eine lokalisierte Zeichenfolge, die The following figure summarizes the encryption process as outlined above: ähnelt.
     1333        ///   Sucht eine lokalisierte Zeichenfolge, die The following figure summarizes the encryption process outlined above on slides 11 to 16. ähnelt.
    9741334        /// </summary>
    9751335        public static string Tutorial1DifferentialCryptanalysisSlide4Content1 {
     
    9891349       
    9901350        /// <summary>
    991         ///   Sucht eine lokalisierte Zeichenfolge, die The cryptoanalyst knows the parameters m and c, but the internal intermediate values u and v are unknown, as k ähnelt.
     1351        ///   Sucht eine lokalisierte Zeichenfolge, die However, these values cannot be directly compared with the internal values u ähnelt.
     1352        /// </summary>
     1353        public static string Tutorial1DifferentialCryptanalysisSlide9bContent6Run1 {
     1354            get {
     1355                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent6Run1", resourceCulture);
     1356            }
     1357        }
     1358       
     1359        /// <summary>
     1360        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1361        /// </summary>
     1362        public static string Tutorial1DifferentialCryptanalysisSlide9bContent6Run2 {
     1363            get {
     1364                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent6Run2", resourceCulture);
     1365            }
     1366        }
     1367       
     1368        /// <summary>
     1369        ///   Sucht eine lokalisierte Zeichenfolge, die  and u ähnelt.
     1370        /// </summary>
     1371        public static string Tutorial1DifferentialCryptanalysisSlide9bContent6Run3 {
     1372            get {
     1373                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent6Run3", resourceCulture);
     1374            }
     1375        }
     1376       
     1377        /// <summary>
     1378        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
     1379        /// </summary>
     1380        public static string Tutorial1DifferentialCryptanalysisSlide9bContent6Run4 {
     1381            get {
     1382                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent6Run4", resourceCulture);
     1383            }
     1384        }
     1385       
     1386        /// <summary>
     1387        ///   Sucht eine lokalisierte Zeichenfolge, die  as these are unknown. ähnelt.
     1388        /// </summary>
     1389        public static string Tutorial1DifferentialCryptanalysisSlide9bContent6Run5 {
     1390            get {
     1391                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent6Run5", resourceCulture);
     1392            }
     1393        }
     1394       
     1395        /// <summary>
     1396        ///   Sucht eine lokalisierte Zeichenfolge, die From equation (1) it follows that if the round key is correctly guessed k ähnelt.
     1397        /// </summary>
     1398        public static string Tutorial1DifferentialCryptanalysisSlide9bContent7Run1 {
     1399            get {
     1400                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent7Run1", resourceCulture);
     1401            }
     1402        }
     1403       
     1404        /// <summary>
     1405        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1406        /// </summary>
     1407        public static string Tutorial1DifferentialCryptanalysisSlide9bContent7Run2 {
     1408            get {
     1409                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent7Run2", resourceCulture);
     1410            }
     1411        }
     1412       
     1413        /// <summary>
     1414        ///   Sucht eine lokalisierte Zeichenfolge, die  the following applies: ähnelt.
     1415        /// </summary>
     1416        public static string Tutorial1DifferentialCryptanalysisSlide9bContent7Run3 {
     1417            get {
     1418                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9bContent7Run3", resourceCulture);
     1419            }
     1420        }
     1421       
     1422        /// <summary>
     1423        ///   Sucht eine lokalisierte Zeichenfolge, die The cryptanalyst knows the parameters m and c, but not the internal intermediate values u and v, since k ähnelt.
    9921424        /// </summary>
    9931425        public static string Tutorial1DifferentialCryptanalysisSlide9Content1Run1 {
     
    10071439       
    10081440        /// <summary>
    1009         ///   Sucht eine lokalisierte Zeichenfolge, die and k ähnelt.
     1441        ///   Sucht eine lokalisierte Zeichenfolge, die  and k ähnelt.
    10101442        /// </summary>
    10111443        public static string Tutorial1DifferentialCryptanalysisSlide9Content1Run3 {
     
    10251457       
    10261458        /// <summary>
    1027         ///   Sucht eine lokalisierte Zeichenfolge, die are unknown. However, the cryptanalyst knows the difference between the internal values. In the following, we look at two messages m ähnelt.
     1459        ///   Sucht eine lokalisierte Zeichenfolge, die  are unknown. However, the cryptanalyst can calculate the difference between the two internal u intermediate values from the difference between the two plaintexts. In the following we consider two messages m ähnelt.
    10281460        /// </summary>
    10291461        public static string Tutorial1DifferentialCryptanalysisSlide9Content1Run5 {
     
    10431475       
    10441476        /// <summary>
    1045         ///   Sucht eine lokalisierte Zeichenfolge, die and m ähnelt.
     1477        ///   Sucht eine lokalisierte Zeichenfolge, die  and m ähnelt.
    10461478        /// </summary>
    10471479        public static string Tutorial1DifferentialCryptanalysisSlide9Content1Run7 {
     
    10611493       
    10621494        /// <summary>
    1063         ///   Sucht eine lokalisierte Zeichenfolge, die and perform the encryption process partially: ähnelt.
     1495        ///   Sucht eine lokalisierte Zeichenfolge, die  and build their difference: ähnelt.
    10641496        /// </summary>
    10651497        public static string Tutorial1DifferentialCryptanalysisSlide9Content1Run9 {
     
    10701502       
    10711503        /// <summary>
    1072         ///   Sucht eine lokalisierte Zeichenfolge, die This knowledge can be used to get k ähnelt.
     1504        ///   Sucht eine lokalisierte Zeichenfolge, die This knowledge can be used to calculate k ähnelt.
    10731505        /// </summary>
    10741506        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run1 {
     
    10881520       
    10891521        /// <summary>
    1090         ///   Sucht eine lokalisierte Zeichenfolge, die ). We can calculate ähnelt.
     1522        ///   Sucht eine lokalisierte Zeichenfolge, die ). According to equation (1), the difference of the u-values is equal to the difference of m ähnelt.
    10911523        /// </summary>
    10921524        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run11 {
     
    10991531        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    11001532        /// </summary>
     1533        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run12 {
     1534            get {
     1535                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content2Run12", resourceCulture);
     1536            }
     1537        }
     1538       
     1539        /// <summary>
     1540        ///   Sucht eine lokalisierte Zeichenfolge, die  and m ähnelt.
     1541        /// </summary>
     1542        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run13 {
     1543            get {
     1544                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content2Run13", resourceCulture);
     1545            }
     1546        }
     1547       
     1548        /// <summary>
     1549        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
     1550        /// </summary>
     1551        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run14 {
     1552            get {
     1553                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content2Run14", resourceCulture);
     1554            }
     1555        }
     1556       
     1557        /// <summary>
     1558        ///   Sucht eine lokalisierte Zeichenfolge, die . Next, k ähnelt.
     1559        /// </summary>
     1560        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run15 {
     1561            get {
     1562                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content2Run15", resourceCulture);
     1563            }
     1564        }
     1565       
     1566        /// <summary>
     1567        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1568        /// </summary>
     1569        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run16 {
     1570            get {
     1571                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content2Run16", resourceCulture);
     1572            }
     1573        }
     1574       
     1575        /// <summary>
     1576        ///   Sucht eine lokalisierte Zeichenfolge, die  is &quot;advised&quot; so that from ähnelt.
     1577        /// </summary>
     1578        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run17 {
     1579            get {
     1580                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content2Run17", resourceCulture);
     1581            }
     1582        }
     1583       
     1584        /// <summary>
     1585        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1586        /// </summary>
    11011587        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run2 {
    11021588            get {
     
    11061592       
    11071593        /// <summary>
    1108         ///   Sucht eine lokalisierte Zeichenfolge, die . We consider two plaintext-ciphertext pairs (m ähnelt.
     1594        ///   Sucht eine lokalisierte Zeichenfolge, die . For this we will consider two pairs of plaintext and ciphertext (m ähnelt.
    11091595        /// </summary>
    11101596        public static string Tutorial1DifferentialCryptanalysisSlide9Content2Run3 {
     
    11691655       
    11701656        /// <summary>
    1171         ///   Sucht eine lokalisierte Zeichenfolge, die by difference calculation of m ähnelt.
     1657        ///   Sucht eine lokalisierte Zeichenfolge, die the values of v ähnelt.
    11721658        /// </summary>
    11731659        public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run1 {
     
    11781664       
    11791665        /// <summary>
     1666        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     1667        /// </summary>
     1668        public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run2 {
     1669            get {
     1670                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run2", resourceCulture);
     1671            }
     1672        }
     1673       
     1674        /// <summary>
     1675        ///   Sucht eine lokalisierte Zeichenfolge, die  and v ähnelt.
     1676        /// </summary>
     1677        public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run3 {
     1678            get {
     1679                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run3", resourceCulture);
     1680            }
     1681        }
     1682       
     1683        /// <summary>
    11801684        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
    11811685        /// </summary>
    1182         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run10 {
    1183             get {
    1184                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run10", resourceCulture);
    1185             }
    1186         }
    1187        
    1188         /// <summary>
    1189         ///   Sucht eine lokalisierte Zeichenfolge, die because the functionality of the SBox is public and therefore invertible. This allows the cryptoanalyst to calculate ähnelt.
    1190         /// </summary>
    1191         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run11 {
    1192             get {
    1193                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run11", resourceCulture);
     1686        public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run4 {
     1687            get {
     1688                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run4", resourceCulture);
     1689            }
     1690        }
     1691       
     1692        /// <summary>
     1693        ///   Sucht eine lokalisierte Zeichenfolge, die  can be calculated. ähnelt.
     1694        /// </summary>
     1695        public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run5 {
     1696            get {
     1697                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run5", resourceCulture);
     1698            }
     1699        }
     1700       
     1701        /// <summary>
     1702        ///   Sucht eine lokalisierte Zeichenfolge, die Because the functionality of the S-Box is public and therefore also invertible, the cryptoanalyst can calculate with ähnelt.
     1703        /// </summary>
     1704        public static string Tutorial1DifferentialCryptanalysisSlide9Content4Run1 {
     1705            get {
     1706                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content4Run1", resourceCulture);
     1707            }
     1708        }
     1709       
     1710        /// <summary>
     1711        ///   Sucht eine lokalisierte Zeichenfolge, die the values of ähnelt.
     1712        /// </summary>
     1713        public static string Tutorial1DifferentialCryptanalysisSlide9Content5Run1 {
     1714            get {
     1715                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content5Run1", resourceCulture);
     1716            }
     1717        }
     1718       
     1719        /// <summary>
     1720        ///   Sucht eine lokalisierte Zeichenfolge, die   ähnelt.
     1721        /// </summary>
     1722        public static string Tutorial1DifferentialCryptanalysisSlide9Content6Run1 {
     1723            get {
     1724                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content6Run1", resourceCulture);
     1725            }
     1726        }
     1727       
     1728        /// <summary>
     1729        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
     1730        /// </summary>
     1731        public static string Tutorial1DifferentialCryptanalysisSlide9Header {
     1732            get {
     1733                return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Header", resourceCulture);
     1734            }
     1735        }
     1736       
     1737        /// <summary>
     1738        ///   Sucht eine lokalisierte Zeichenfolge, die 1. Introduction ähnelt.
     1739        /// </summary>
     1740        public static string Tutorial1IntroductionHeader {
     1741            get {
     1742                return ResourceManager.GetString("Tutorial1IntroductionHeader", resourceCulture);
     1743            }
     1744        }
     1745       
     1746        /// <summary>
     1747        ///   Sucht eine lokalisierte Zeichenfolge, die In this section we consider the basic idea of differential cryptanalysis. ähnelt.
     1748        /// </summary>
     1749        public static string Tutorial1IntroductionSlide1Content1Run1 {
     1750            get {
     1751                return ResourceManager.GetString("Tutorial1IntroductionSlide1Content1Run1", resourceCulture);
     1752            }
     1753        }
     1754       
     1755        /// <summary>
     1756        ///   Sucht eine lokalisierte Zeichenfolge, die Most modern round-based block ciphers consist of three basic operations: key addition, substitution, and permutation. Cipher 1 consists of key addition and substitution. Ciphers 2 and 3 also contain a permutation. ähnelt.
     1757        /// </summary>
     1758        public static string Tutorial1IntroductionSlide1Content1Run2 {
     1759            get {
     1760                return ResourceManager.GetString("Tutorial1IntroductionSlide1Content1Run2", resourceCulture);
     1761            }
     1762        }
     1763       
     1764        /// <summary>
     1765        ///   Sucht eine lokalisierte Zeichenfolge, die The XOR operation (exclusive OR) is usually used for key addition. The XOR operation is a two-digit operator that can be described by the following value table: ähnelt.
     1766        /// </summary>
     1767        public static string Tutorial1IntroductionSlide1Content2 {
     1768            get {
     1769                return ResourceManager.GetString("Tutorial1IntroductionSlide1Content2", resourceCulture);
     1770            }
     1771        }
     1772       
     1773        /// <summary>
     1774        ///   Sucht eine lokalisierte Zeichenfolge, die Input bit A ähnelt.
     1775        /// </summary>
     1776        public static string Tutorial1IntroductionSlide1DataColHeader1 {
     1777            get {
     1778                return ResourceManager.GetString("Tutorial1IntroductionSlide1DataColHeader1", resourceCulture);
     1779            }
     1780        }
     1781       
     1782        /// <summary>
     1783        ///   Sucht eine lokalisierte Zeichenfolge, die Input bit B ähnelt.
     1784        /// </summary>
     1785        public static string Tutorial1IntroductionSlide1DataColHeader2 {
     1786            get {
     1787                return ResourceManager.GetString("Tutorial1IntroductionSlide1DataColHeader2", resourceCulture);
     1788            }
     1789        }
     1790       
     1791        /// <summary>
     1792        ///   Sucht eine lokalisierte Zeichenfolge, die result bit ähnelt.
     1793        /// </summary>
     1794        public static string Tutorial1IntroductionSlide1DataColHeader3 {
     1795            get {
     1796                return ResourceManager.GetString("Tutorial1IntroductionSlide1DataColHeader3", resourceCulture);
     1797            }
     1798        }
     1799       
     1800        /// <summary>
     1801        ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
     1802        /// </summary>
     1803        public static string Tutorial1IntroductionSlide1Header {
     1804            get {
     1805                return ResourceManager.GetString("Tutorial1IntroductionSlide1Header", resourceCulture);
     1806            }
     1807        }
     1808       
     1809        /// <summary>
     1810        ///   Sucht eine lokalisierte Zeichenfolge, die If the XOR operation is used to encrypt a message m with key k, the ciphertext c is obtained as follows: ähnelt.
     1811        /// </summary>
     1812        public static string Tutorial1IntroductionSlide2Content1 {
     1813            get {
     1814                return ResourceManager.GetString("Tutorial1IntroductionSlide2Content1", resourceCulture);
     1815            }
     1816        }
     1817       
     1818        /// <summary>
     1819        ///   Sucht eine lokalisierte Zeichenfolge, die The basic idea of differential cryptanalysis is to use the effect of a property of the XOR operation by using the key k twice. If the key addition is performed twice, the following applies: ähnelt.
     1820        /// </summary>
     1821        public static string Tutorial1IntroductionSlide2Content2 {
     1822            get {
     1823                return ResourceManager.GetString("Tutorial1IntroductionSlide2Content2", resourceCulture);
     1824            }
     1825        }
     1826       
     1827        /// <summary>
     1828        ///   Sucht eine lokalisierte Zeichenfolge, die We get back the original message m. ähnelt.
     1829        /// </summary>
     1830        public static string Tutorial1IntroductionSlide2Content3Run1 {
     1831            get {
     1832                return ResourceManager.GetString("Tutorial1IntroductionSlide2Content3Run1", resourceCulture);
     1833            }
     1834        }
     1835       
     1836        /// <summary>
     1837        ///   Sucht eine lokalisierte Zeichenfolge, die The XOR operator is often referred to as the difference operator. This name is also used in this tutorial. ähnelt.
     1838        /// </summary>
     1839        public static string Tutorial1IntroductionSlide2Content3Run2 {
     1840            get {
     1841                return ResourceManager.GetString("Tutorial1IntroductionSlide2Content3Run2", resourceCulture);
     1842            }
     1843        }
     1844       
     1845        /// <summary>
     1846        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis is a so-called &quot;chosen plaintext attack&quot;, which means that the cryptanalyst can select plaintext messages and encrypt them to have matching plaintext/ciphertext pairs. ähnelt.
     1847        /// </summary>
     1848        public static string Tutorial1IntroductionSlide2Content4 {
     1849            get {
     1850                return ResourceManager.GetString("Tutorial1IntroductionSlide2Content4", resourceCulture);
     1851            }
     1852        }
     1853       
     1854        /// <summary>
     1855        ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
     1856        /// </summary>
     1857        public static string Tutorial1IntroductionSlide2Header {
     1858            get {
     1859                return ResourceManager.GetString("Tutorial1IntroductionSlide2Header", resourceCulture);
     1860            }
     1861        }
     1862       
     1863        /// <summary>
     1864        ///   Sucht eine lokalisierte Zeichenfolge, die We take advantage of the idea of using the key twice by using pairs of messages m ähnelt.
     1865        /// </summary>
     1866        public static string Tutorial1IntroductionSlide3Content1Run1 {
     1867            get {
     1868                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run1", resourceCulture);
    11941869            }
    11951870        }
     
    11981873        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    11991874        /// </summary>
    1200         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run2 {
    1201             get {
    1202                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run2", resourceCulture);
    1203             }
    1204         }
    1205        
    1206         /// <summary>
    1207         ///   Sucht eine lokalisierte Zeichenfolge, die and m ähnelt.
    1208         /// </summary>
    1209         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run3 {
    1210             get {
    1211                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run3", resourceCulture);
     1875        public static string Tutorial1IntroductionSlide3Content1Run2 {
     1876            get {
     1877                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run2", resourceCulture);
     1878            }
     1879        }
     1880       
     1881        /// <summary>
     1882        ///   Sucht eine lokalisierte Zeichenfolge, die  and m ähnelt.
     1883        /// </summary>
     1884        public static string Tutorial1IntroductionSlide3Content1Run3 {
     1885            get {
     1886                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run3", resourceCulture);
    12121887            }
    12131888        }
     
    12161891        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
    12171892        /// </summary>
    1218         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run4 {
    1219             get {
    1220                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run4", resourceCulture);
    1221             }
    1222         }
    1223        
    1224         /// <summary>
    1225         ///   Sucht eine lokalisierte Zeichenfolge, die . Next step is k ähnelt.
    1226         /// </summary>
    1227         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run5 {
    1228             get {
    1229                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run5", resourceCulture);
     1893        public static string Tutorial1IntroductionSlide3Content1Run4 {
     1894            get {
     1895                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run4", resourceCulture);
     1896            }
     1897        }
     1898       
     1899        /// <summary>
     1900        ///   Sucht eine lokalisierte Zeichenfolge, die . If the difference between the ciphertexts is now formed, the following holds true: ähnelt.
     1901        /// </summary>
     1902        public static string Tutorial1IntroductionSlide3Content1Run5 {
     1903            get {
     1904                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run5", resourceCulture);
     1905            }
     1906        }
     1907       
     1908        /// <summary>
     1909        ///   Sucht eine lokalisierte Zeichenfolge, die It follows: ähnelt.
     1910        /// </summary>
     1911        public static string Tutorial1IntroductionSlide3Content2 {
     1912            get {
     1913                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content2", resourceCulture);
     1914            }
     1915        }
     1916       
     1917        /// <summary>
     1918        ///   Sucht eine lokalisierte Zeichenfolge, die We obtain the difference of the plaintexts by calculating the difference of the ciphertexts. This can be used to obtain information about the round keys at dca. ähnelt.
     1919        /// </summary>
     1920        public static string Tutorial1IntroductionSlide3Content3 {
     1921            get {
     1922                return ResourceManager.GetString("Tutorial1IntroductionSlide3Content3", resourceCulture);
     1923            }
     1924        }
     1925       
     1926        /// <summary>
     1927        ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
     1928        /// </summary>
     1929        public static string Tutorial1IntroductionSlide3Header {
     1930            get {
     1931                return ResourceManager.GetString("Tutorial1IntroductionSlide3Header", resourceCulture);
     1932            }
     1933        }
     1934       
     1935        /// <summary>
     1936        ///   Sucht eine lokalisierte Zeichenfolge, die The dca is now continued in the DCA KeyRecovery component. ähnelt.
     1937        /// </summary>
     1938        public static string Tutorial1LastSlideContent1 {
     1939            get {
     1940                return ResourceManager.GetString("Tutorial1LastSlideContent1", resourceCulture);
     1941            }
     1942        }
     1943       
     1944        /// <summary>
     1945        ///   Sucht eine lokalisierte Zeichenfolge, die In the DCA KeyRecovery component, you can now recover the round keys k ähnelt.
     1946        /// </summary>
     1947        public static string Tutorial1LastSlideContent2Run1 {
     1948            get {
     1949                return ResourceManager.GetString("Tutorial1LastSlideContent2Run1", resourceCulture);
    12301950            }
    12311951        }
     
    12341954        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    12351955        /// </summary>
    1236         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run6 {
    1237             get {
    1238                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run6", resourceCulture);
    1239             }
    1240         }
    1241        
    1242         /// <summary>
    1243         ///   Sucht eine lokalisierte Zeichenfolge, die and the values of v ähnelt.
    1244         /// </summary>
    1245         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run7 {
    1246             get {
    1247                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run7", resourceCulture);
     1956        public static string Tutorial1LastSlideContent2Run2 {
     1957            get {
     1958                return ResourceManager.GetString("Tutorial1LastSlideContent2Run2", resourceCulture);
     1959            }
     1960        }
     1961       
     1962        /// <summary>
     1963        ///   Sucht eine lokalisierte Zeichenfolge, die  and k ähnelt.
     1964        /// </summary>
     1965        public static string Tutorial1LastSlideContent2Run3 {
     1966            get {
     1967                return ResourceManager.GetString("Tutorial1LastSlideContent2Run3", resourceCulture);
     1968            }
     1969        }
     1970       
     1971        /// <summary>
     1972        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     1973        /// </summary>
     1974        public static string Tutorial1LastSlideContent2Run4 {
     1975            get {
     1976                return ResourceManager.GetString("Tutorial1LastSlideContent2Run4", resourceCulture);
     1977            }
     1978        }
     1979       
     1980        /// <summary>
     1981        ///   Sucht eine lokalisierte Zeichenfolge, die . ähnelt.
     1982        /// </summary>
     1983        public static string Tutorial1LastSlideContent2Run5 {
     1984            get {
     1985                return ResourceManager.GetString("Tutorial1LastSlideContent2Run5", resourceCulture);
     1986            }
     1987        }
     1988       
     1989        /// <summary>
     1990        ///   Sucht eine lokalisierte Zeichenfolge, die To do this, you must click on the ähnelt.
     1991        /// </summary>
     1992        public static string Tutorial1LastSlideContent3Run1 {
     1993            get {
     1994                return ResourceManager.GetString("Tutorial1LastSlideContent3Run1", resourceCulture);
     1995            }
     1996        }
     1997       
     1998        /// <summary>
     1999        ///   Sucht eine lokalisierte Zeichenfolge, die Start-Button ähnelt.
     2000        /// </summary>
     2001        public static string Tutorial1LastSlideContent3Run2 {
     2002            get {
     2003                return ResourceManager.GetString("Tutorial1LastSlideContent3Run2", resourceCulture);
     2004            }
     2005        }
     2006       
     2007        /// <summary>
     2008        ///   Sucht eine lokalisierte Zeichenfolge, die in the DCA KeyRecovery component. ähnelt.
     2009        /// </summary>
     2010        public static string Tutorial1LastSlideContent3Run3 {
     2011            get {
     2012                return ResourceManager.GetString("Tutorial1LastSlideContent3Run3", resourceCulture);
     2013            }
     2014        }
     2015       
     2016        /// <summary>
     2017        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 1 finished ähnelt.
     2018        /// </summary>
     2019        public static string Tutorial1LastSlideHeader {
     2020            get {
     2021                return ResourceManager.GetString("Tutorial1LastSlideHeader", resourceCulture);
     2022            }
     2023        }
     2024       
     2025        /// <summary>
     2026        ///   Sucht eine lokalisierte Zeichenfolge, die 3. Performing differential cryptanalysis ähnelt.
     2027        /// </summary>
     2028        public static string Tutorial1PracticalDifferentialCryptanalysisHeader {
     2029            get {
     2030                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisHeader", resourceCulture);
     2031            }
     2032        }
     2033       
     2034        /// <summary>
     2035        ///   Sucht eine lokalisierte Zeichenfolge, die In the dca against cipher 1, the round keys k ähnelt.
     2036        /// </summary>
     2037        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run1 {
     2038            get {
     2039                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run1", resourceCulture);
    12482040            }
    12492041        }
     
    12522044        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    12532045        /// </summary>
    1254         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run8 {
    1255             get {
    1256                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run8", resourceCulture);
    1257             }
    1258         }
    1259        
    1260         /// <summary>
    1261         ///   Sucht eine lokalisierte Zeichenfolge, die and v ähnelt.
    1262         /// </summary>
    1263         public static string Tutorial1DifferentialCryptanalysisSlide9Content3Run9 {
    1264             get {
    1265                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content3Run9", resourceCulture);
    1266             }
    1267         }
    1268        
    1269         /// <summary>
    1270         ///   Sucht eine lokalisierte Zeichenfolge, die However, these values cannot be directly compared with the internal values u ähnelt.
    1271         /// </summary>
    1272         public static string Tutorial1DifferentialCryptanalysisSlide9Content4Run1 {
    1273             get {
    1274                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content4Run1", resourceCulture);
     2046        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run2 {
     2047            get {
     2048                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run2", resourceCulture);
     2049            }
     2050        }
     2051       
     2052        /// <summary>
     2053        ///   Sucht eine lokalisierte Zeichenfolge, die  and k ähnelt.
     2054        /// </summary>
     2055        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run3 {
     2056            get {
     2057                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run3", resourceCulture);
     2058            }
     2059        }
     2060       
     2061        /// <summary>
     2062        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2063        /// </summary>
     2064        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run4 {
     2065            get {
     2066                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run4", resourceCulture);
     2067            }
     2068        }
     2069       
     2070        /// <summary>
     2071        ///   Sucht eine lokalisierte Zeichenfolge, die  will be attacked. The attack proceeds as described in this tutorial. ähnelt.
     2072        /// </summary>
     2073        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run5 {
     2074            get {
     2075                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run5", resourceCulture);
     2076            }
     2077        }
     2078       
     2079        /// <summary>
     2080        ///   Sucht eine lokalisierte Zeichenfolge, die Click on Next (right arrow below) to start the attack. The control is passed on to the DCA KeyRecovery component. ähnelt.
     2081        /// </summary>
     2082        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content2 {
     2083            get {
     2084                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content2", resourceCulture);
     2085            }
     2086        }
     2087       
     2088        /// <summary>
     2089        ///   Sucht eine lokalisierte Zeichenfolge, die Performing differential cryptanalysis ähnelt.
     2090        /// </summary>
     2091        public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Header {
     2092            get {
     2093                return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Header", resourceCulture);
     2094            }
     2095        }
     2096       
     2097        /// <summary>
     2098        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial ähnelt.
     2099        /// </summary>
     2100        public static string Tutorial1TitleHeaderRun1 {
     2101            get {
     2102                return ResourceManager.GetString("Tutorial1TitleHeaderRun1", resourceCulture);
     2103            }
     2104        }
     2105       
     2106        /// <summary>
     2107        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of symmetric block ciphers ähnelt.
     2108        /// </summary>
     2109        public static string Tutorial1TitleHeaderRun2 {
     2110            get {
     2111                return ResourceManager.GetString("Tutorial1TitleHeaderRun2", resourceCulture);
     2112            }
     2113        }
     2114       
     2115        /// <summary>
     2116        ///   Sucht eine lokalisierte Zeichenfolge, die 2. Analyse von Chiffre 2 ähnelt.
     2117        /// </summary>
     2118        public static string Tutorial2AnalysisHeader {
     2119            get {
     2120                return ResourceManager.GetString("Tutorial2AnalysisHeader", resourceCulture);
     2121            }
     2122        }
     2123       
     2124        /// <summary>
     2125        ///   Sucht eine lokalisierte Zeichenfolge, die 3. Analyse der SBoxen ähnelt.
     2126        /// </summary>
     2127        public static string Tutorial2AnalysisOfSBoxHeader {
     2128            get {
     2129                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxHeader", resourceCulture);
     2130            }
     2131        }
     2132       
     2133        /// <summary>
     2134        ///   Sucht eine lokalisierte Zeichenfolge, die Aufgrund der Schlüsseladdition verhält sich die SBox nicht-linear. Ein Rateversuch für K3 kann nicht direkt überprüft werden. ähnelt.
     2135        /// </summary>
     2136        public static string Tutorial2AnalysisOfSBoxSlide1Content1 {
     2137            get {
     2138                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content1", resourceCulture);
     2139            }
     2140        }
     2141       
     2142        /// <summary>
     2143        ///   Sucht eine lokalisierte Zeichenfolge, die Alle SBoxen von Chiffre 2 verhalten sind identisch. Aus diesem Grund ist es aussreichend, wenn die Funktionsweise einer einzelnen SBox analysiert wird. Grundsätzlich ist es möglich, 4 parallele SBoxen als eine große SBox zu betrachten, dies würde aber den Analyseaufwand erhöhen. Die SBox erhält als Eingabe 4 Bits und gibt auch 4 Bits als Ausgabe aus. Die 4 Eingabe-Bits werden durch 4 andere Ausgabe-Bits ersetzt. ähnelt.
     2144        /// </summary>
     2145        public static string Tutorial2AnalysisOfSBoxSlide1Content2 {
     2146            get {
     2147                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content2", resourceCulture);
     2148            }
     2149        }
     2150       
     2151        /// <summary>
     2152        ///   Sucht eine lokalisierte Zeichenfolge, die Zur Erinnerung: Bei der differenziellen Kryptoanalyse wird mit Differenzen von Nachrichten gearbeitet. Um die SBox zu untersuchen, werden alle Kombinationen von Eingabe-Klartexten betrachtet und deren Differenz gebildet. Je Paar werden die Klartexte einzelnt in die SBox gegeben und anschließend die Differenz der substituierte Ausgaben berechnet. Dabei werden die Übergänge von Eingabe- zu Ausgabe-Differenz notiert. ähnelt.
     2153        /// </summary>
     2154        public static string Tutorial2AnalysisOfSBoxSlide1Content3 {
     2155            get {
     2156                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content3", resourceCulture);
     2157            }
     2158        }
     2159       
     2160        /// <summary>
     2161        ///   Sucht eine lokalisierte Zeichenfolge, die Die Tabelle auf der nächsten Seite visualisiert dieses Vorgehen. Für jede mögliche Eingabe-Differenz existiert eine Zeile. Für jede mögliche Ausgabe-Differenz gibt es eine Spalte. Die Anzahl des Auftretens einer speziellen Differenz wird durch die Einträge der Tabelle beschrieben. ähnelt.
     2162        /// </summary>
     2163        public static string Tutorial2AnalysisOfSBoxSlide1Content4 {
     2164            get {
     2165                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content4", resourceCulture);
     2166            }
     2167        }
     2168       
     2169        /// <summary>
     2170        ///   Sucht eine lokalisierte Zeichenfolge, die Um die Wahrscheinlichkeit des Auftretens einer Differenz zu Berechnen, muss die Anzahl durch 16 geteilt werden. ähnelt.
     2171        /// </summary>
     2172        public static string Tutorial2AnalysisOfSBoxSlide1Content5 {
     2173            get {
     2174                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content5", resourceCulture);
     2175            }
     2176        }
     2177       
     2178        /// <summary>
     2179        ///   Sucht eine lokalisierte Zeichenfolge, die Analyse der SBoxen ähnelt.
     2180        /// </summary>
     2181        public static string Tutorial2AnalysisOfSBoxSlide1Header {
     2182            get {
     2183                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Header", resourceCulture);
     2184            }
     2185        }
     2186       
     2187        /// <summary>
     2188        ///   Sucht eine lokalisierte Zeichenfolge, die Im Folgenden ist die Differenz-Verteilungstabelle zu sehen: ähnelt.
     2189        /// </summary>
     2190        public static string Tutorial2AnalysisOfSBoxSlide2Content1 {
     2191            get {
     2192                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2Content1", resourceCulture);
     2193            }
     2194        }
     2195       
     2196        /// <summary>
     2197        ///   Sucht eine lokalisierte Zeichenfolge, die Analyse der SBoxen ähnelt.
     2198        /// </summary>
     2199        public static string Tutorial2AnalysisOfSBoxSlide2Header {
     2200            get {
     2201                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2Header", resourceCulture);
     2202            }
     2203        }
     2204       
     2205        /// <summary>
     2206        ///   Sucht eine lokalisierte Zeichenfolge, die Eingabe-Differenz ähnelt.
     2207        /// </summary>
     2208        public static string Tutorial2AnalysisOfSBoxSlide2InputDifference {
     2209            get {
     2210                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2InputDifference", resourceCulture);
     2211            }
     2212        }
     2213       
     2214        /// <summary>
     2215        ///   Sucht eine lokalisierte Zeichenfolge, die Ausgabe-Differenz ähnelt.
     2216        /// </summary>
     2217        public static string Tutorial2AnalysisOfSBoxSlide2OutputDifference {
     2218            get {
     2219                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2OutputDifference", resourceCulture);
     2220            }
     2221        }
     2222       
     2223        /// <summary>
     2224        ///   Sucht eine lokalisierte Zeichenfolge, die Die Ein- und Ausgabe-Differenzen sowie die Einträge der Differenzverteilungs-Tabelle sind hexadezimal. ähnelt.
     2225        /// </summary>
     2226        public static string Tutorial2AnalysisOfSBoxSlide3Content1 {
     2227            get {
     2228                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content1", resourceCulture);
     2229            }
     2230        }
     2231       
     2232        /// <summary>
     2233        ///   Sucht eine lokalisierte Zeichenfolge, die Bei einer 4 Bit SBox gibt es je 16 verschiedene Eingaben und Ausgaben. Kombiniert man 2 Nachrichten zu einem Nachrichtenpaar mit je disjunkten Differenzen, können 256 verschiedene Übergänge von Differenzen beobachtet werden. ähnelt.
     2234        /// </summary>
     2235        public static string Tutorial2AnalysisOfSBoxSlide3Content2 {
     2236            get {
     2237                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content2", resourceCulture);
     2238            }
     2239        }
     2240       
     2241        /// <summary>
     2242        ///   Sucht eine lokalisierte Zeichenfolge, die Eine wichtige Beobachtung ist, dass es Differenzen gibt, die häufiger vorkommen als andere. Es gibt auch Differenzen, die gar nicht auftreten. Zum Beispiel wird die Eingabe-Differenz 8 insgesamt 8 mal auf die Ausgabe-Differenz D abgebildet. ähnelt.
     2243        /// </summary>
     2244        public static string Tutorial2AnalysisOfSBoxSlide3Content3 {
     2245            get {
     2246                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content3", resourceCulture);
     2247            }
     2248        }
     2249       
     2250        /// <summary>
     2251        ///   Sucht eine lokalisierte Zeichenfolge, die Die Verteilung der Differenzen ist offensichtlich nicht gleichverteilt. In der Praxis sind SBoxen nicht perfekt. Diesen Fakt macht sich der Kryptoanalyst zu nutze. Besonders hohe Wahrscheinlichkeiten helfen bei der differenziellen Kryptoanalyse. ähnelt.
     2252        /// </summary>
     2253        public static string Tutorial2AnalysisOfSBoxSlide3Content4 {
     2254            get {
     2255                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content4", resourceCulture);
     2256            }
     2257        }
     2258       
     2259        /// <summary>
     2260        ///   Sucht eine lokalisierte Zeichenfolge, die Analyse der SBoxen ähnelt.
     2261        /// </summary>
     2262        public static string Tutorial2AnalysisOfSBoxSlide3Header {
     2263            get {
     2264                return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Header", resourceCulture);
     2265            }
     2266        }
     2267       
     2268        /// <summary>
     2269        ///   Sucht eine lokalisierte Zeichenfolge, die Chiffre 2 besteht aus drei Verschlüsselungsrunden mit vier Rundenschlüsseln. Jede Runde besteht aus Schlüsseladdition, Substitution und einer Permutation. In der letzten Runde wird zusätzlich noch eine weitere Schlüsseladdition durchgeführt. ähnelt.
     2270        /// </summary>
     2271        public static string Tutorial2AnalysisSlide1Content1 {
     2272            get {
     2273                return ResourceManager.GetString("Tutorial2AnalysisSlide1Content1", resourceCulture);
     2274            }
     2275        }
     2276       
     2277        /// <summary>
     2278        ///   Sucht eine lokalisierte Zeichenfolge, die Im Folgenden wird die Verschlüsselung eines Klartextblocks schematisch dargestellt. Analog zu Tutorial 1 werden die internen Zustände während des Verschlüsselungsprozesses mit Variablen u und v bezeichnet. ähnelt.
     2279        /// </summary>
     2280        public static string Tutorial2AnalysisSlide1Content2 {
     2281            get {
     2282                return ResourceManager.GetString("Tutorial2AnalysisSlide1Content2", resourceCulture);
     2283            }
     2284        }
     2285       
     2286        /// <summary>
     2287        ///   Sucht eine lokalisierte Zeichenfolge, die In dieser Chiffre wird zusätzlich eine Permutation verwendet. Diese vertauscht die Bitpositionen eines Blocks. Im Schema wird die Permutation mit P() bezeichnet. Zusätzlich zu den internen Zuständen u und v wird w eingeführt. Dieser Zustand repräsentiert den Wert nach einer Permutation. ähnelt.
     2288        /// </summary>
     2289        public static string Tutorial2AnalysisSlide1Content3 {
     2290            get {
     2291                return ResourceManager.GetString("Tutorial2AnalysisSlide1Content3", resourceCulture);
     2292            }
     2293        }
     2294       
     2295        /// <summary>
     2296        ///   Sucht eine lokalisierte Zeichenfolge, die Analyse von Chiffre 2 ähnelt.
     2297        /// </summary>
     2298        public static string Tutorial2AnalysisSlide1Header {
     2299            get {
     2300                return ResourceManager.GetString("Tutorial2AnalysisSlide1Header", resourceCulture);
     2301            }
     2302        }
     2303       
     2304        /// <summary>
     2305        ///   Sucht eine lokalisierte Zeichenfolge, die Analyse von Chiffre 2 ähnelt.
     2306        /// </summary>
     2307        public static string Tutorial2AnalysisSlide2Header {
     2308            get {
     2309                return ResourceManager.GetString("Tutorial2AnalysisSlide2Header", resourceCulture);
     2310            }
     2311        }
     2312       
     2313        /// <summary>
     2314        ///   Sucht eine lokalisierte Zeichenfolge, die Man könnte nun versuchen, den Schlüssel k ähnelt.
     2315        /// </summary>
     2316        public static string Tutorial2AnalysisSlide3Content1Run1 {
     2317            get {
     2318                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run1", resourceCulture);
     2319            }
     2320        }
     2321       
     2322        /// <summary>
     2323        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2324        /// </summary>
     2325        public static string Tutorial2AnalysisSlide3Content1Run10 {
     2326            get {
     2327                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run10", resourceCulture);
     2328            }
     2329        }
     2330       
     2331        /// <summary>
     2332        ///   Sucht eine lokalisierte Zeichenfolge, die  berechnen. Mit den Klartexten ist man noch in der Lage, die Differenz der u ähnelt.
     2333        /// </summary>
     2334        public static string Tutorial2AnalysisSlide3Content1Run11 {
     2335            get {
     2336                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run11", resourceCulture);
     2337            }
     2338        }
     2339       
     2340        /// <summary>
     2341        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2342        /// </summary>
     2343        public static string Tutorial2AnalysisSlide3Content1Run12 {
     2344            get {
     2345                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run12", resourceCulture);
     2346            }
     2347        }
     2348       
     2349        /// <summary>
     2350        ///   Sucht eine lokalisierte Zeichenfolge, die  zu berechnen. ähnelt.
     2351        /// </summary>
     2352        public static string Tutorial2AnalysisSlide3Content1Run13 {
     2353            get {
     2354                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run13", resourceCulture);
     2355            }
     2356        }
     2357       
     2358        /// <summary>
     2359        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2360        /// </summary>
     2361        public static string Tutorial2AnalysisSlide3Content1Run2 {
     2362            get {
     2363                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run2", resourceCulture);
     2364            }
     2365        }
     2366       
     2367        /// <summary>
     2368        ///   Sucht eine lokalisierte Zeichenfolge, die  in ähnlicher Art und Weise wie bei Chiffre 1 anzugreifen. Dazu hätte man ein Paar von Klartexten und ihre entsprechenden Geheimtexte vorliegen. Dann würde man einen möglichen Rundenschlüssel t raten und die jeweiligen internen Variablen v ähnelt.
     2369        /// </summary>
     2370        public static string Tutorial2AnalysisSlide3Content1Run3 {
     2371            get {
     2372                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run3", resourceCulture);
     2373            }
     2374        }
     2375       
     2376        /// <summary>
     2377        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2378        /// </summary>
     2379        public static string Tutorial2AnalysisSlide3Content1Run4 {
     2380            get {
     2381                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run4", resourceCulture);
     2382            }
     2383        }
     2384       
     2385        /// <summary>
     2386        ///   Sucht eine lokalisierte Zeichenfolge, die  berechnen. Dadurch könnte man u ähnelt.
     2387        /// </summary>
     2388        public static string Tutorial2AnalysisSlide3Content1Run5 {
     2389            get {
     2390                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run5", resourceCulture);
     2391            }
     2392        }
     2393       
     2394        /// <summary>
     2395        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2396        /// </summary>
     2397        public static string Tutorial2AnalysisSlide3Content1Run6 {
     2398            get {
     2399                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run6", resourceCulture);
     2400            }
     2401        }
     2402       
     2403        /// <summary>
     2404        ///   Sucht eine lokalisierte Zeichenfolge, die  berechnen. Da der Rundenschlüssel k ähnelt.
     2405        /// </summary>
     2406        public static string Tutorial2AnalysisSlide3Content1Run7 {
     2407            get {
     2408                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run7", resourceCulture);
     2409            }
     2410        }
     2411       
     2412        /// <summary>
     2413        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
     2414        /// </summary>
     2415        public static string Tutorial2AnalysisSlide3Content1Run8 {
     2416            get {
     2417                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run8", resourceCulture);
     2418            }
     2419        }
     2420       
     2421        /// <summary>
     2422        ///   Sucht eine lokalisierte Zeichenfolge, die  ebenfalls unbekannt ist, könnte man nun die Differenz der u ähnelt.
     2423        /// </summary>
     2424        public static string Tutorial2AnalysisSlide3Content1Run9 {
     2425            get {
     2426                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1Run9", resourceCulture);
     2427            }
     2428        }
     2429       
     2430        /// <summary>
     2431        ///   Sucht eine lokalisierte Zeichenfolge, die Aufgrund des Exclusive-Oder verhält sich die SBox nicht-linear, sodass man die Differenz der v ähnelt.
     2432        /// </summary>
     2433        public static string Tutorial2AnalysisSlide3Content2Run1 {
     2434            get {
     2435                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content2Run1", resourceCulture);
     2436            }
     2437        }
     2438       
     2439        /// <summary>
     2440        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2441        /// </summary>
     2442        public static string Tutorial2AnalysisSlide3Content2Run2 {
     2443            get {
     2444                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content2Run2", resourceCulture);
     2445            }
     2446        }
     2447       
     2448        /// <summary>
     2449        ///   Sucht eine lokalisierte Zeichenfolge, die  nicht bestimmen kann. Daher ist es nicht möglich einen Rateversuch von k ähnelt.
     2450        /// </summary>
     2451        public static string Tutorial2AnalysisSlide3Content2Run3 {
     2452            get {
     2453                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content2Run3", resourceCulture);
     2454            }
     2455        }
     2456       
     2457        /// <summary>
     2458        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2459        /// </summary>
     2460        public static string Tutorial2AnalysisSlide3Content2Run4 {
     2461            get {
     2462                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content2Run4", resourceCulture);
     2463            }
     2464        }
     2465       
     2466        /// <summary>
     2467        ///   Sucht eine lokalisierte Zeichenfolge, die  durch Nutzung von Differenzen zu prüfen. ähnelt.
     2468        /// </summary>
     2469        public static string Tutorial2AnalysisSlide3Content2Run5 {
     2470            get {
     2471                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content2Run5", resourceCulture);
     2472            }
     2473        }
     2474       
     2475        /// <summary>
     2476        ///   Sucht eine lokalisierte Zeichenfolge, die Um dieses Problem zu lösen, betrachten wir die Funktionsweise der SBoxen genauer. ähnelt.
     2477        /// </summary>
     2478        public static string Tutorial2AnalysisSlide3Content3 {
     2479            get {
     2480                return ResourceManager.GetString("Tutorial2AnalysisSlide3Content3", resourceCulture);
     2481            }
     2482        }
     2483       
     2484        /// <summary>
     2485        ///   Sucht eine lokalisierte Zeichenfolge, die Analyse von Chiffre 2 ähnelt.
     2486        /// </summary>
     2487        public static string Tutorial2AnalysisSlide3Header {
     2488            get {
     2489                return ResourceManager.GetString("Tutorial2AnalysisSlide3Header", resourceCulture);
     2490            }
     2491        }
     2492       
     2493        /// <summary>
     2494        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2 zur differenziellen Kryptoanalyse in der DKA-PfadFinder-Komponente ist beendet.  ähnelt.
     2495        /// </summary>
     2496        public static string Tutorial2AttackFinishedContent1 {
     2497            get {
     2498                return ResourceManager.GetString("Tutorial2AttackFinishedContent1", resourceCulture);
     2499            }
     2500        }
     2501       
     2502        /// <summary>
     2503        ///   Sucht eine lokalisierte Zeichenfolge, die Durch ein letztes Klicken auf &quot;Start&quot; in der DKA-KeyRecovery-Komponente werden die letzten zwei Rundenschlüssel k ähnelt.
     2504        /// </summary>
     2505        public static string Tutorial2AttackFinishedContent2Run1 {
     2506            get {
     2507                return ResourceManager.GetString("Tutorial2AttackFinishedContent2Run1", resourceCulture);
    12752508            }
    12762509        }
     
    12792512        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    12802513        /// </summary>
    1281         public static string Tutorial1DifferentialCryptanalysisSlide9Content4Run2 {
    1282             get {
    1283                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content4Run2", resourceCulture);
    1284             }
    1285         }
    1286        
    1287         /// <summary>
    1288         ///   Sucht eine lokalisierte Zeichenfolge, die and u ähnelt.
    1289         /// </summary>
    1290         public static string Tutorial1DifferentialCryptanalysisSlide9Content4Run3 {
    1291             get {
    1292                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content4Run3", resourceCulture);
     2514        public static string Tutorial2AttackFinishedContent2Run2 {
     2515            get {
     2516                return ResourceManager.GetString("Tutorial2AttackFinishedContent2Run2", resourceCulture);
     2517            }
     2518        }
     2519       
     2520        /// <summary>
     2521        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     2522        /// </summary>
     2523        public static string Tutorial2AttackFinishedContent2Run3 {
     2524            get {
     2525                return ResourceManager.GetString("Tutorial2AttackFinishedContent2Run3", resourceCulture);
     2526            }
     2527        }
     2528       
     2529        /// <summary>
     2530        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2531        /// </summary>
     2532        public static string Tutorial2AttackFinishedContent2Run4 {
     2533            get {
     2534                return ResourceManager.GetString("Tutorial2AttackFinishedContent2Run4", resourceCulture);
     2535            }
     2536        }
     2537       
     2538        /// <summary>
     2539        ///   Sucht eine lokalisierte Zeichenfolge, die  versucht wiederherzustellen. ähnelt.
     2540        /// </summary>
     2541        public static string Tutorial2AttackFinishedContent2Run5 {
     2542            get {
     2543                return ResourceManager.GetString("Tutorial2AttackFinishedContent2Run5", resourceCulture);
     2544            }
     2545        }
     2546       
     2547        /// <summary>
     2548        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2 beendet ähnelt.
     2549        /// </summary>
     2550        public static string Tutorial2AttackFinishedHeader {
     2551            get {
     2552                return ResourceManager.GetString("Tutorial2AttackFinishedHeader", resourceCulture);
     2553            }
     2554        }
     2555       
     2556        /// <summary>
     2557        ///   Sucht eine lokalisierte Zeichenfolge, die Im letzten Schritt werden die letzten beiden Rundenschlüssel k ähnelt.
     2558        /// </summary>
     2559        public static string Tutorial2AttackFirstRoundContent1Run1 {
     2560            get {
     2561                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent1Run1", resourceCulture);
     2562            }
     2563        }
     2564       
     2565        /// <summary>
     2566        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     2567        /// </summary>
     2568        public static string Tutorial2AttackFirstRoundContent1Run2 {
     2569            get {
     2570                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent1Run2", resourceCulture);
     2571            }
     2572        }
     2573       
     2574        /// <summary>
     2575        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     2576        /// </summary>
     2577        public static string Tutorial2AttackFirstRoundContent1Run3 {
     2578            get {
     2579                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent1Run3", resourceCulture);
     2580            }
     2581        }
     2582       
     2583        /// <summary>
     2584        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2585        /// </summary>
     2586        public static string Tutorial2AttackFirstRoundContent1Run4 {
     2587            get {
     2588                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent1Run4", resourceCulture);
     2589            }
     2590        }
     2591       
     2592        /// <summary>
     2593        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen. Dieser Angriff läuft analog zu dem Verfahren ab, wie es in Tutorial 1 durchgeführt wurde. ähnelt.
     2594        /// </summary>
     2595        public static string Tutorial2AttackFirstRoundContent1Run5 {
     2596            get {
     2597                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent1Run5", resourceCulture);
     2598            }
     2599        }
     2600       
     2601        /// <summary>
     2602        ///   Sucht eine lokalisierte Zeichenfolge, die Durch einen Klick auf weiter werden die ersten beiden Rundenschlüssel k ähnelt.
     2603        /// </summary>
     2604        public static string Tutorial2AttackFirstRoundContent2Run1 {
     2605            get {
     2606                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent2Run1", resourceCulture);
     2607            }
     2608        }
     2609       
     2610        /// <summary>
     2611        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     2612        /// </summary>
     2613        public static string Tutorial2AttackFirstRoundContent2Run2 {
     2614            get {
     2615                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent2Run2", resourceCulture);
     2616            }
     2617        }
     2618       
     2619        /// <summary>
     2620        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     2621        /// </summary>
     2622        public static string Tutorial2AttackFirstRoundContent2Run3 {
     2623            get {
     2624                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent2Run3", resourceCulture);
     2625            }
     2626        }
     2627       
     2628        /// <summary>
     2629        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2630        /// </summary>
     2631        public static string Tutorial2AttackFirstRoundContent2Run4 {
     2632            get {
     2633                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent2Run4", resourceCulture);
     2634            }
     2635        }
     2636       
     2637        /// <summary>
     2638        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen. ähnelt.
     2639        /// </summary>
     2640        public static string Tutorial2AttackFirstRoundContent2Run5 {
     2641            get {
     2642                return ResourceManager.GetString("Tutorial2AttackFirstRoundContent2Run5", resourceCulture);
     2643            }
     2644        }
     2645       
     2646        /// <summary>
     2647        ///   Sucht eine lokalisierte Zeichenfolge, die Berechnung der Rundenschlüssel k ähnelt.
     2648        /// </summary>
     2649        public static string Tutorial2AttackFirstRoundHeaderRun1 {
     2650            get {
     2651                return ResourceManager.GetString("Tutorial2AttackFirstRoundHeaderRun1", resourceCulture);
     2652            }
     2653        }
     2654       
     2655        /// <summary>
     2656        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     2657        /// </summary>
     2658        public static string Tutorial2AttackFirstRoundHeaderRun2 {
     2659            get {
     2660                return ResourceManager.GetString("Tutorial2AttackFirstRoundHeaderRun2", resourceCulture);
     2661            }
     2662        }
     2663       
     2664        /// <summary>
     2665        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     2666        /// </summary>
     2667        public static string Tutorial2AttackFirstRoundHeaderRun3 {
     2668            get {
     2669                return ResourceManager.GetString("Tutorial2AttackFirstRoundHeaderRun3", resourceCulture);
     2670            }
     2671        }
     2672       
     2673        /// <summary>
     2674        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     2675        /// </summary>
     2676        public static string Tutorial2AttackFirstRoundHeaderRun4 {
     2677            get {
     2678                return ResourceManager.GetString("Tutorial2AttackFirstRoundHeaderRun4", resourceCulture);
     2679            }
     2680        }
     2681       
     2682        /// <summary>
     2683        ///   Sucht eine lokalisierte Zeichenfolge, die 7. Differenzielle Kryptoanalyse von Chiffre 2 ähnelt.
     2684        /// </summary>
     2685        public static string Tutorial2AttackHeader {
     2686            get {
     2687                return ResourceManager.GetString("Tutorial2AttackHeader", resourceCulture);
     2688            }
     2689        }
     2690       
     2691        /// <summary>
     2692        ///   Sucht eine lokalisierte Zeichenfolge, die An dieser Stelle soll der zweite Rundenschlüssel k ähnelt.
     2693        /// </summary>
     2694        public static string Tutorial2AttackKeyRound2Content1Run1 {
     2695            get {
     2696                return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run1", resourceCulture);
    12932697            }
    12942698        }
     
    12972701        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
    12982702        /// </summary>
    1299         public static string Tutorial1DifferentialCryptanalysisSlide9Content4Run4 {
    1300             get {
    1301                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content4Run4", resourceCulture);
    1302             }
    1303         }
    1304        
    1305         /// <summary>
    1306         ///   Sucht eine lokalisierte Zeichenfolge, die as these are unknown. ähnelt.
    1307         /// </summary>
    1308         public static string Tutorial1DifferentialCryptanalysisSlide9Content4Run5 {
    1309             get {
    1310                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content4Run5", resourceCulture);
    1311             }
    1312         }
    1313        
    1314         /// <summary>
    1315         ///   Sucht eine lokalisierte Zeichenfolge, die However, the cryptoanalyst knows that if the round key k ähnelt.
    1316         /// </summary>
    1317         public static string Tutorial1DifferentialCryptanalysisSlide9Content5Run1 {
    1318             get {
    1319                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content5Run1", resourceCulture);
     2703        public static string Tutorial2AttackKeyRound2Content1Run2 {
     2704            get {
     2705                return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run2", resourceCulture);
     2706            }
     2707        }
     2708       
     2709        /// <summary>
     2710        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen werden. Dazu können in der zweiten Verschlüsselungsrunde SBoxen ausgewählt werden. Durch die Auswahl einer SBox werden die jeweiligen 4 Bits des Rundenschlüssels angegriffen und versucht wiederherzustellen. ähnelt.
     2711        /// </summary>
     2712        public static string Tutorial2AttackKeyRound2Content1Run3 {
     2713            get {
     2714                return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run3", resourceCulture);
     2715            }
     2716        }
     2717       
     2718        /// <summary>
     2719        ///   Sucht eine lokalisierte Zeichenfolge, die Der Angriff läuft nahezu analog zu dem auf den Rundenschlüssel k ähnelt.
     2720        /// </summary>
     2721        public static string Tutorial2AttackKeyRound2Content1Run4 {
     2722            get {
     2723                return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run4", resourceCulture);
     2724            }
     2725        }
     2726       
     2727        /// <summary>
     2728        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2729        /// </summary>
     2730        public static string Tutorial2AttackKeyRound2Content1Run5 {
     2731            get {
     2732                return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run5", resourceCulture);
     2733            }
     2734        }
     2735       
     2736        /// <summary>
     2737        ///   Sucht eine lokalisierte Zeichenfolge, die  ab. Allerdings muss bei der Suche nach Differenzialen die Chiffre nicht mehr so tief durchsucht werden, da bereits eine Verschlüsselungsrunde vollständig angegriffen wurde. ähnelt.
     2738        /// </summary>
     2739        public static string Tutorial2AttackKeyRound2Content1Run6 {
     2740            get {
     2741                return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run6", resourceCulture);
     2742            }
     2743        }
     2744       
     2745        /// <summary>
     2746        ///   Sucht eine lokalisierte Zeichenfolge, die An dieser Stelle soll der erste Rundenschlüssel k ähnelt.
     2747        /// </summary>
     2748        public static string Tutorial2AttackKeyRound3Content1Run1 {
     2749            get {
     2750                return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run1", resourceCulture);
     2751            }
     2752        }
     2753       
     2754        /// <summary>
     2755        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2756        /// </summary>
     2757        public static string Tutorial2AttackKeyRound3Content1Run2 {
     2758            get {
     2759                return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run2", resourceCulture);
     2760            }
     2761        }
     2762       
     2763        /// <summary>
     2764        ///   Sucht eine lokalisierte Zeichenfolge, die  der Chiffre angegriffen werden. Dazu können in der dritten Verschlüsselungsrunde SBoxen ausgewählt werden. Durch die Auswahl einer SBox werden die jeweiligen 4 Bits des Rundenschlüssels angegriffen und versucht wiederherzustellen. ähnelt.
     2765        /// </summary>
     2766        public static string Tutorial2AttackKeyRound3Content1Run3 {
     2767            get {
     2768                return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run3", resourceCulture);
     2769            }
     2770        }
     2771       
     2772        /// <summary>
     2773        ///   Sucht eine lokalisierte Zeichenfolge, die Bei der differenziellen Kryptoanalyse wird die Veränderung von Differenzen an den SBoxen betrachtet. Daher sind an dieser Stelle SBoxen auszuwählen. ähnelt.
     2774        /// </summary>
     2775        public static string Tutorial2AttackKeyRound3Content1Run4 {
     2776            get {
     2777                return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run4", resourceCulture);
     2778            }
     2779        }
     2780       
     2781        /// <summary>
     2782        ///   Sucht eine lokalisierte Zeichenfolge, die Je mehr Schlüsselbits ausgewählt werden, desto komplizierter ist die Suche nach einem Differenzial. Allerdings kann durchaus sinnvoll sein, mehrere SBoxen gleichzeitig anzugreifen. Je nach Beschaffenheit der Chiffre finden sich so bessere oder schlechtere Differenziale. ähnelt.
     2783        /// </summary>
     2784        public static string Tutorial2AttackKeyRound3Content1Run5 {
     2785            get {
     2786                return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run5", resourceCulture);
     2787            }
     2788        }
     2789       
     2790        /// <summary>
     2791        ///   Sucht eine lokalisierte Zeichenfolge, die SBoxen aus Runde 2 auswählen, um Schlüsselbits von k ähnelt.
     2792        /// </summary>
     2793        public static string Tutorial2AttackRound2HeaderRun1 {
     2794            get {
     2795                return ResourceManager.GetString("Tutorial2AttackRound2HeaderRun1", resourceCulture);
     2796            }
     2797        }
     2798       
     2799        /// <summary>
     2800        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
     2801        /// </summary>
     2802        public static string Tutorial2AttackRound2HeaderRun2 {
     2803            get {
     2804                return ResourceManager.GetString("Tutorial2AttackRound2HeaderRun2", resourceCulture);
     2805            }
     2806        }
     2807       
     2808        /// <summary>
     2809        ///   Sucht eine lokalisierte Zeichenfolge, die  anzugreifen ähnelt.
     2810        /// </summary>
     2811        public static string Tutorial2AttackRound2HeaderRun3 {
     2812            get {
     2813                return ResourceManager.GetString("Tutorial2AttackRound2HeaderRun3", resourceCulture);
     2814            }
     2815        }
     2816       
     2817        /// <summary>
     2818        ///   Sucht eine lokalisierte Zeichenfolge, die SBoxen aus Runde 3 auswählen, um Schlüsselbits von k ähnelt.
     2819        /// </summary>
     2820        public static string Tutorial2AttackRound3HeaderRun1 {
     2821            get {
     2822                return ResourceManager.GetString("Tutorial2AttackRound3HeaderRun1", resourceCulture);
     2823            }
     2824        }
     2825       
     2826        /// <summary>
     2827        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     2828        /// </summary>
     2829        public static string Tutorial2AttackRound3HeaderRun2 {
     2830            get {
     2831                return ResourceManager.GetString("Tutorial2AttackRound3HeaderRun2", resourceCulture);
     2832            }
     2833        }
     2834       
     2835        /// <summary>
     2836        ///   Sucht eine lokalisierte Zeichenfolge, die  anzugreifen ähnelt.
     2837        /// </summary>
     2838        public static string Tutorial2AttackRound3HeaderRun3 {
     2839            get {
     2840                return ResourceManager.GetString("Tutorial2AttackRound3HeaderRun3", resourceCulture);
     2841            }
     2842        }
     2843       
     2844        /// <summary>
     2845        ///   Sucht eine lokalisierte Zeichenfolge, die 4. Charakteristiken ähnelt.
     2846        /// </summary>
     2847        public static string Tutorial2CharacteristicHeader {
     2848            get {
     2849                return ResourceManager.GetString("Tutorial2CharacteristicHeader", resourceCulture);
     2850            }
     2851        }
     2852       
     2853        /// <summary>
     2854        ///   Sucht eine lokalisierte Zeichenfolge, die Zwei Eingaben, die sich durch eine Differenz  ähnelt.
     2855        /// </summary>
     2856        public static string Tutorial2CharacteristicSlide1Content1Run1 {
     2857            get {
     2858                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1Run1", resourceCulture);
     2859            }
     2860        }
     2861       
     2862        /// <summary>
     2863        ///   Sucht eine lokalisierte Zeichenfolge, die  unterscheiden, werden unter Verwendung der SBox durch ein Paar von Ausgaben substitutiert, welche sich durch eine Differenz  ähnelt.
     2864        /// </summary>
     2865        public static string Tutorial2CharacteristicSlide1Content1Run2 {
     2866            get {
     2867                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1Run2", resourceCulture);
     2868            }
     2869        }
     2870       
     2871        /// <summary>
     2872        ///   Sucht eine lokalisierte Zeichenfolge, die  unterscheiden. Notiert wird dies durch  ähnelt.
     2873        /// </summary>
     2874        public static string Tutorial2CharacteristicSlide1Content1Run3 {
     2875            get {
     2876                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1Run3", resourceCulture);
     2877            }
     2878        }
     2879       
     2880        /// <summary>
     2881        ///   Sucht eine lokalisierte Zeichenfolge, die Charakteristiken können miteinander kombiniert und so über mehrere Runden verbunden werden. Vorraussetzung dafür ist, dass die Ausgangsdifferenz der vorgänger Charakteristik denselben Wert wie die Eingangsdifferenz der nachfolgenden Charakteristik aufweist. Unter der Annahme, dass Charakteristiken unabhängig voneinander sind, können die Wahrscheinlichkeiten multipliziert werden. Auf diese Weise kann ein Weg von Differenzen durch die Chiffre gesucht werden. ähnelt.
     2882        /// </summary>
     2883        public static string Tutorial2CharacteristicSlide1Content2 {
     2884            get {
     2885                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content2", resourceCulture);
     2886            }
     2887        }
     2888       
     2889        /// <summary>
     2890        ///   Sucht eine lokalisierte Zeichenfolge, die Wir bezeichnen ein solches Paar  ähnelt.
     2891        /// </summary>
     2892        public static string Tutorial2CharacteristicSlide1Content2Run1 {
     2893            get {
     2894                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content2Run1", resourceCulture);
     2895            }
     2896        }
     2897       
     2898        /// <summary>
     2899        ///   Sucht eine lokalisierte Zeichenfolge, die  als differenzielle charakteristik unter der Operation der SBox. Wie zuvor gesehen, hat eine differenzielle Charakteristik eine feste Wahrscheinlichkeit. ähnelt.
     2900        /// </summary>
     2901        public static string Tutorial2CharacteristicSlide1Content2Run2 {
     2902            get {
     2903                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content2Run2", resourceCulture);
     2904            }
     2905        }
     2906       
     2907        /// <summary>
     2908        ///   Sucht eine lokalisierte Zeichenfolge, die Ziel bei der Suche ist es einen Weg zu finden, der eine möglichst hohe Wahrscheinlichkeit aufweist. Diese Wege können in der DKA-PfadVisualisierer-Komponente graphisch dargestellt werden. ähnelt.
     2909        /// </summary>
     2910        public static string Tutorial2CharacteristicSlide1Content3 {
     2911            get {
     2912                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content3", resourceCulture);
     2913            }
     2914        }
     2915       
     2916        /// <summary>
     2917        ///   Sucht eine lokalisierte Zeichenfolge, die Charakteristiken ähnelt.
     2918        /// </summary>
     2919        public static string Tutorial2CharacteristicSlide1Header {
     2920            get {
     2921                return ResourceManager.GetString("Tutorial2CharacteristicSlide1Header", resourceCulture);
     2922            }
     2923        }
     2924       
     2925        /// <summary>
     2926        ///   Sucht eine lokalisierte Zeichenfolge, die Eine Verschlüsselungsrunde besteht bei Chiffre 2 aus Schlüsseladdition, Substitution und Permutation. Die Chiffre arbeitet auf 16 Bit Blöcken. Die vorige Notation wird wie folgt erweitert, um eine differenzielle Charakteristik einer SBox für 16 Bit Blöcke zu bezeichnen ähnelt.
     2927        /// </summary>
     2928        public static string Tutorial2CharacteristicSlide2Content1 {
     2929            get {
     2930                return ResourceManager.GetString("Tutorial2CharacteristicSlide2Content1", resourceCulture);
     2931            }
     2932        }
     2933       
     2934        /// <summary>
     2935        ///   Sucht eine lokalisierte Zeichenfolge, die Nach der Substitution werden die Bits in Chiffre 2 permutiert. Die Permutation der Chiffre ist bekannt und daher kann die differenzielle Charakteristik der Permutation wie folgt bezeichnet werden ähnelt.
     2936        /// </summary>
     2937        public static string Tutorial2CharacteristicSlide2Content2 {
     2938            get {
     2939                return ResourceManager.GetString("Tutorial2CharacteristicSlide2Content2", resourceCulture);
     2940            }
     2941        }
     2942       
     2943        /// <summary>
     2944        ///   Sucht eine lokalisierte Zeichenfolge, die Zusammenfassend wird eine differenzielle Charakteristik einer Verschlüsselungsrunde als Komination von Substitution und Permutation wie folgt notiert ähnelt.
     2945        /// </summary>
     2946        public static string Tutorial2CharacteristicSlide2Content3 {
     2947            get {
     2948                return ResourceManager.GetString("Tutorial2CharacteristicSlide2Content3", resourceCulture);
     2949            }
     2950        }
     2951       
     2952        /// <summary>
     2953        ///   Sucht eine lokalisierte Zeichenfolge, die Charakteristiken ähnelt.
     2954        /// </summary>
     2955        public static string Tutorial2CharacteristicSlide2Header {
     2956            get {
     2957                return ResourceManager.GetString("Tutorial2CharacteristicSlide2Header", resourceCulture);
     2958            }
     2959        }
     2960       
     2961        /// <summary>
     2962        ///   Sucht eine lokalisierte Zeichenfolge, die Die differenziellen Charakteristiken einzelner Runde sollen jetzt zu einem Weg von Differenzen durch die gesamte Chiffre kombiniert werden. Die Suche nach Pfaden mit hoher Wahrscheinlichkeit ist ein aufwändiges und zeitaufwändiges Problem bei Chiffren mit vielen Verschlüsselungsrunden und langen Blöcken. ähnelt.
     2963        /// </summary>
     2964        public static string Tutorial2CharacteristicSlide3Content1 {
     2965            get {
     2966                return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content1", resourceCulture);
     2967            }
     2968        }
     2969       
     2970        /// <summary>
     2971        ///   Sucht eine lokalisierte Zeichenfolge, die Die DKA-PfadFinder-Komponente verfügt über verschiedene Suchoptionen zur Bestimmung von solchen Pfaden. ähnelt.
     2972        /// </summary>
     2973        public static string Tutorial2CharacteristicSlide3Content2 {
     2974            get {
     2975                return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content2", resourceCulture);
     2976            }
     2977        }
     2978       
     2979        /// <summary>
     2980        ///   Sucht eine lokalisierte Zeichenfolge, die Die zuvor eingeführte Notation wird verwendet, um differenzielle Charakteristiken einer Runde zu differenziellen Charakteristiken für n-Verschlüsselungsrunden (hier: 3) zu bezeichnen: ähnelt.
     2981        /// </summary>
     2982        public static string Tutorial2CharacteristicSlide3Content3 {
     2983            get {
     2984                return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content3", resourceCulture);
     2985            }
     2986        }
     2987       
     2988        /// <summary>
     2989        ///   Sucht eine lokalisierte Zeichenfolge, die Im ersten 4-Tupel sind die Eingangsdifferenzen der SBoxen der ersten 4 SBoxen in der ersten Verschlüsselungsrunde angegeben. Im 2. 4-Tupel ist sowohl die Ausgangsdifferenz der ersten als auch die Eingangsdifferenz der zweiten Verschlüsselungsrunde notiert. Im 3. 4-Tupel ist die Ausgangsdifferenz der zweiten und die Eingangsdifferenz der letzten Verschlüsselungsrunde notiert. ähnelt.
     2990        /// </summary>
     2991        public static string Tutorial2CharacteristicSlide3Content4 {
     2992            get {
     2993                return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content4", resourceCulture);
     2994            }
     2995        }
     2996       
     2997        /// <summary>
     2998        ///   Sucht eine lokalisierte Zeichenfolge, die Ziel bei der Suche ist es, einen Weg zu finden, der eine möglichst hohe Wahrscheinlichkeit aufweist. ähnelt.
     2999        /// </summary>
     3000        public static string Tutorial2CharacteristicSlide3Content5 {
     3001            get {
     3002                return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content5", resourceCulture);
     3003            }
     3004        }
     3005       
     3006        /// <summary>
     3007        ///   Sucht eine lokalisierte Zeichenfolge, die Charakteristiken ähnelt.
     3008        /// </summary>
     3009        public static string Tutorial2CharacteristicSlide3Header {
     3010            get {
     3011                return ResourceManager.GetString("Tutorial2CharacteristicSlide3Header", resourceCulture);
     3012            }
     3013        }
     3014       
     3015        /// <summary>
     3016        ///   Sucht eine lokalisierte Zeichenfolge, die 5. Differenziale ähnelt.
     3017        /// </summary>
     3018        public static string Tutorial2DifferentialHeader {
     3019            get {
     3020                return ResourceManager.GetString("Tutorial2DifferentialHeader", resourceCulture);
     3021            }
     3022        }
     3023       
     3024        /// <summary>
     3025        ///   Sucht eine lokalisierte Zeichenfolge, die Bei der Suche nach Charakteristiken über n Runden kann es vorkommen, dass dass verschiedene Charakteristiken gefunden werden, die die selbe Eingangsdifferenz der ersten und Ausgangsdifferenz der letzten Verschlüsselungsrunde haben. Die Charakteristiken haben also die Form ähnelt.
     3026        /// </summary>
     3027        public static string Tutorial2DifferentialSlide1Content1 {
     3028            get {
     3029                return ResourceManager.GetString("Tutorial2DifferentialSlide1Content1", resourceCulture);
     3030            }
     3031        }
     3032       
     3033        /// <summary>
     3034        ///   Sucht eine lokalisierte Zeichenfolge, die Entscheidend bei der Verwendung von Charakteristiken für die differenzielle Kryptoanalyse sind Eingangs- und Ausgangswert der Differenz. Findet man mehrere Charakteristiken mit selben Eingangs- und Ausgangswert, können die Wahrscheinlichkeiten addiert werden. Eine Struktur, die aus mehreren Charakteristiken besteht, wird Differenzial genannt. ähnelt.
     3035        /// </summary>
     3036        public static string Tutorial2DifferentialSlide1Content2 {
     3037            get {
     3038                return ResourceManager.GetString("Tutorial2DifferentialSlide1Content2", resourceCulture);
     3039            }
     3040        }
     3041       
     3042        /// <summary>
     3043        ///   Sucht eine lokalisierte Zeichenfolge, die Ziel bei der Analyse einer Chiffre ist es also, das Differenzial mit der höchsten Wahrscheinlichkeit zu finden. ähnelt.
     3044        /// </summary>
     3045        public static string Tutorial2DifferentialSlide1Content3 {
     3046            get {
     3047                return ResourceManager.GetString("Tutorial2DifferentialSlide1Content3", resourceCulture);
     3048            }
     3049        }
     3050       
     3051        /// <summary>
     3052        ///   Sucht eine lokalisierte Zeichenfolge, die Differenziale ähnelt.
     3053        /// </summary>
     3054        public static string Tutorial2DifferentialSlide1Header {
     3055            get {
     3056                return ResourceManager.GetString("Tutorial2DifferentialSlide1Header", resourceCulture);
     3057            }
     3058        }
     3059       
     3060        /// <summary>
     3061        ///   Sucht eine lokalisierte Zeichenfolge, die 1. Einführung ähnelt.
     3062        /// </summary>
     3063        public static string Tutorial2IntroductionHeader {
     3064            get {
     3065                return ResourceManager.GetString("Tutorial2IntroductionHeader", resourceCulture);
     3066            }
     3067        }
     3068       
     3069        /// <summary>
     3070        ///   Sucht eine lokalisierte Zeichenfolge, die In Tutorial 1 wurde die Idee der differenziellen Kryptoanalyse vorgestellt und an einer Chiffre bestehend aus einer Verschlüsselungsrunde mit zwei Rundenschlüsseln demonstriert. ähnelt.
     3071        /// </summary>
     3072        public static string Tutorial2IntroductionSlide1Content1 {
     3073            get {
     3074                return ResourceManager.GetString("Tutorial2IntroductionSlide1Content1", resourceCulture);
     3075            }
     3076        }
     3077       
     3078        /// <summary>
     3079        ///   Sucht eine lokalisierte Zeichenfolge, die In diesem Tutorial wird die Idee vertieft und an einer Chiffre mit drei Verschlüsselungsrunden mit vier Rundenschlüsseln gezeigt. ähnelt.
     3080        /// </summary>
     3081        public static string Tutorial2IntroductionSlide1Content2 {
     3082            get {
     3083                return ResourceManager.GetString("Tutorial2IntroductionSlide1Content2", resourceCulture);
     3084            }
     3085        }
     3086       
     3087        /// <summary>
     3088        ///   Sucht eine lokalisierte Zeichenfolge, die Um eine Chiffre mit mehreren Verschlüsselgsrunden und Rundenschlüsseln mittels differenzieller Kryptoanalyse anzugreifen, muss diese genauer untersucht werden. Von Interesse sind die einzelnen Bestandteile der Verschlüsselungsrunden und wie diese sich verhalten. ähnelt.
     3089        /// </summary>
     3090        public static string Tutorial2IntroductionSlide1Content3 {
     3091            get {
     3092                return ResourceManager.GetString("Tutorial2IntroductionSlide1Content3", resourceCulture);
     3093            }
     3094        }
     3095       
     3096        /// <summary>
     3097        ///   Sucht eine lokalisierte Zeichenfolge, die Aufgrund der mehrfachen Verschlüsselungsrunden kann diese Chiffre nicht wie Chiffre 1 angegriffen werden. Für Chiffre 2 wird ein Ansatz benötigt, der die Änderungen von Differenzen über mehrere Verschlüsselungsrunden mit einer gewissen Wahrscheinlichkeit vorraussagt. ähnelt.
     3098        /// </summary>
     3099        public static string Tutorial2IntroductionSlide1Content4 {
     3100            get {
     3101                return ResourceManager.GetString("Tutorial2IntroductionSlide1Content4", resourceCulture);
     3102            }
     3103        }
     3104       
     3105        /// <summary>
     3106        ///   Sucht eine lokalisierte Zeichenfolge, die Einführung ähnelt.
     3107        /// </summary>
     3108        public static string Tutorial2IntroductionSlide1Header {
     3109            get {
     3110                return ResourceManager.GetString("Tutorial2IntroductionSlide1Header", resourceCulture);
     3111            }
     3112        }
     3113       
     3114        /// <summary>
     3115        ///   Sucht eine lokalisierte Zeichenfolge, die 6. Schlüsselinformationen wiederherstellen ähnelt.
     3116        /// </summary>
     3117        public static string Tutorial2RecoverKeyInformationHeader {
     3118            get {
     3119                return ResourceManager.GetString("Tutorial2RecoverKeyInformationHeader", resourceCulture);
     3120            }
     3121        }
     3122       
     3123        /// <summary>
     3124        ///   Sucht eine lokalisierte Zeichenfolge, die Sobald ein Differenzial mit hoher Wahrscheinlichkeit gefunden wurde, kann damit begonnen werden, Schlüsselbits wiederherzustellen. Dazu werden die SBoxen betrachtet, an denen die erwartete Differenz von 0 verschieden ist. ähnelt.
     3125        /// </summary>
     3126        public static string Tutorial2RecoverKeyInformationSlide1Content1 {
     3127            get {
     3128                return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Content1", resourceCulture);
     3129            }
     3130        }
     3131       
     3132        /// <summary>
     3133        ///   Sucht eine lokalisierte Zeichenfolge, die Für jeden möglichen Schlüsselkandidat wird ein Zähler erzeugt. Der Kryptoanalyst generiert eine Anzahl von Nachrichten, die die Eingabedifferenz erfüllen. Diese werden verschlüsselt und mit dem Schlüsselkandidat partiell entschlüsselt. Erfüllt die Differenz der partiell entschlüsselten Nachrichten die erwartete Differenz, wird der Zähler um 1 erhöht. Diesen Prozess wiederholt man mit allen generierten Nachrichtenpaaren. ähnelt.
     3134        /// </summary>
     3135        public static string Tutorial2RecoverKeyInformationSlide1Content2 {
     3136            get {
     3137                return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Content2", resourceCulture);
     3138            }
     3139        }
     3140       
     3141        /// <summary>
     3142        ///   Sucht eine lokalisierte Zeichenfolge, die Der Schlüsselkandidat mit den meisten Treffern, sollte den höchsten Zähler haben. Dieser sollte sehr nah am Erwartungswert des Differenzial liegen. ähnelt.
     3143        /// </summary>
     3144        public static string Tutorial2RecoverKeyInformationSlide1Content3 {
     3145            get {
     3146                return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Content3", resourceCulture);
     3147            }
     3148        }
     3149       
     3150        /// <summary>
     3151        ///   Sucht eine lokalisierte Zeichenfolge, die Schlüsselinformationen wiederherstellen ähnelt.
     3152        /// </summary>
     3153        public static string Tutorial2RecoverKeyInformationSlide1Header {
     3154            get {
     3155                return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Header", resourceCulture);
     3156            }
     3157        }
     3158       
     3159        /// <summary>
     3160        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial ähnelt.
     3161        /// </summary>
     3162        public static string Tutorial2TitleHeaderRun1 {
     3163            get {
     3164                return ResourceManager.GetString("Tutorial2TitleHeaderRun1", resourceCulture);
     3165            }
     3166        }
     3167       
     3168        /// <summary>
     3169        ///   Sucht eine lokalisierte Zeichenfolge, die Differenzielle Kryptoanalyse symmetrischer Blockchiffren ähnelt.
     3170        /// </summary>
     3171        public static string Tutorial2TitleHeaderRun2 {
     3172            get {
     3173                return ResourceManager.GetString("Tutorial2TitleHeaderRun2", resourceCulture);
     3174            }
     3175        }
     3176       
     3177        /// <summary>
     3178        ///   Sucht eine lokalisierte Zeichenfolge, die Sie können nun in der DKA-KeyRecovery-Komponente die in der DKA-PfadFinder-Komponente generierte Angriffskonfiguration verwenden, um Schlüsselbits wiederherzustellen. Dazu müssen Sie auf den Start-Button klicken. ähnelt.
     3179        /// </summary>
     3180        public static string Tutorial2WaitingSlideContent1 {
     3181            get {
     3182                return ResourceManager.GetString("Tutorial2WaitingSlideContent1", resourceCulture);
     3183            }
     3184        }
     3185       
     3186        /// <summary>
     3187        ///   Sucht eine lokalisierte Zeichenfolge, die Optional können Sie sich in der DKA-PfadVisualiserer-Komponente das ermittelte Differenzial und die darin enthaltenen Charakteristiken anzeigen lassen. ähnelt.
     3188        /// </summary>
     3189        public static string Tutorial2WaitingSlideContent2 {
     3190            get {
     3191                return ResourceManager.GetString("Tutorial2WaitingSlideContent2", resourceCulture);
     3192            }
     3193        }
     3194       
     3195        /// <summary>
     3196        ///   Sucht eine lokalisierte Zeichenfolge, die Zusammenfassung der Analyse-Ergebnisse: ähnelt.
     3197        /// </summary>
     3198        public static string Tutorial2WaitingSlideContent3Run1 {
     3199            get {
     3200                return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run1", resourceCulture);
     3201            }
     3202        }
     3203       
     3204        /// <summary>
     3205        ///   Sucht eine lokalisierte Zeichenfolge, die Eingabedifferenz:  ähnelt.
     3206        /// </summary>
     3207        public static string Tutorial2WaitingSlideContent3Run2 {
     3208            get {
     3209                return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run2", resourceCulture);
     3210            }
     3211        }
     3212       
     3213        /// <summary>
     3214        ///   Sucht eine lokalisierte Zeichenfolge, die Erwartete Differenz:  ähnelt.
     3215        /// </summary>
     3216        public static string Tutorial2WaitingSlideContent3Run3 {
     3217            get {
     3218                return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run3", resourceCulture);
     3219            }
     3220        }
     3221       
     3222        /// <summary>
     3223        ///   Sucht eine lokalisierte Zeichenfolge, die Wahrscheinlichkeit:  ähnelt.
     3224        /// </summary>
     3225        public static string Tutorial2WaitingSlideContent3Run4 {
     3226            get {
     3227                return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run4", resourceCulture);
     3228            }
     3229        }
     3230       
     3231        /// <summary>
     3232        ///   Sucht eine lokalisierte Zeichenfolge, die Differenzielle Kryptoanalyse wird in den nachfolgenden Komponenten weitergeführt ähnelt.
     3233        /// </summary>
     3234        public static string Tutorial2WaitingSlideHeader {
     3235            get {
     3236                return ResourceManager.GetString("Tutorial2WaitingSlideHeader", resourceCulture);
     3237            }
     3238        }
     3239       
     3240        /// <summary>
     3241        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 3 zur differenziellen Kryptoanalyse in der DKA-PfadFinder-Komponente ist beendet.  ähnelt.
     3242        /// </summary>
     3243        public static string Tutorial3AttackFinishedContent1 {
     3244            get {
     3245                return ResourceManager.GetString("Tutorial3AttackFinishedContent1", resourceCulture);
     3246            }
     3247        }
     3248       
     3249        /// <summary>
     3250        ///   Sucht eine lokalisierte Zeichenfolge, die Durch ein letztes Klicken auf &quot;Start&quot; in der DKA-KeyRecovery-Komponente werden die letzten zwei Rundenschlüssel k ähnelt.
     3251        /// </summary>
     3252        public static string Tutorial3AttackFinishedContent2Run1 {
     3253            get {
     3254                return ResourceManager.GetString("Tutorial3AttackFinishedContent2Run1", resourceCulture);
    13203255            }
    13213256        }
     
    13243259        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    13253260        /// </summary>
    1326         public static string Tutorial1DifferentialCryptanalysisSlide9Content5Run2 {
    1327             get {
    1328                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content5Run2", resourceCulture);
    1329             }
    1330         }
    1331        
    1332         /// <summary>
    1333         ///   Sucht eine lokalisierte Zeichenfolge, die is valid, the following applies: ähnelt.
    1334         /// </summary>
    1335         public static string Tutorial1DifferentialCryptanalysisSlide9Content5Run3 {
    1336             get {
    1337                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Content5Run3", resourceCulture);
    1338             }
    1339         }
    1340        
    1341         /// <summary>
    1342         ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
    1343         /// </summary>
    1344         public static string Tutorial1DifferentialCryptanalysisSlide9Header {
    1345             get {
    1346                 return ResourceManager.GetString("Tutorial1DifferentialCryptanalysisSlide9Header", resourceCulture);
    1347             }
    1348         }
    1349        
    1350         /// <summary>
    1351         ///   Sucht eine lokalisierte Zeichenfolge, die 1. IntroductionHeader ähnelt.
    1352         /// </summary>
    1353         public static string Tutorial1IntroductionHeader {
    1354             get {
    1355                 return ResourceManager.GetString("Tutorial1IntroductionHeader", resourceCulture);
    1356             }
    1357         }
    1358        
    1359         /// <summary>
    1360         ///   Sucht eine lokalisierte Zeichenfolge, die In this section we consider the basic idea of differential cryptanalysis. Many symmetric round-based block ciphers consist of three basic operations: Key addition, substitution and permutation. In this section, we limit ourselves to key addition and substitution. ähnelt.
    1361         /// </summary>
    1362         public static string Tutorial1IntroductionSlide1Content1 {
    1363             get {
    1364                 return ResourceManager.GetString("Tutorial1IntroductionSlide1Content1", resourceCulture);
    1365             }
    1366         }
    1367        
    1368         /// <summary>
    1369         ///   Sucht eine lokalisierte Zeichenfolge, die Many ciphers use the XOR operation (exclusive-OR) for key addition. The XOR operation is a two-digit operator that can be described by the following value table: ähnelt.
    1370         /// </summary>
    1371         public static string Tutorial1IntroductionSlide1Content2 {
    1372             get {
    1373                 return ResourceManager.GetString("Tutorial1IntroductionSlide1Content2", resourceCulture);
    1374             }
    1375         }
    1376        
    1377         /// <summary>
    1378         ///   Sucht eine lokalisierte Zeichenfolge, die Inputbit A ähnelt.
    1379         /// </summary>
    1380         public static string Tutorial1IntroductionSlide1DataColHeader1 {
    1381             get {
    1382                 return ResourceManager.GetString("Tutorial1IntroductionSlide1DataColHeader1", resourceCulture);
    1383             }
    1384         }
    1385        
    1386         /// <summary>
    1387         ///   Sucht eine lokalisierte Zeichenfolge, die Inputbit B ähnelt.
    1388         /// </summary>
    1389         public static string Tutorial1IntroductionSlide1DataColHeader2 {
    1390             get {
    1391                 return ResourceManager.GetString("Tutorial1IntroductionSlide1DataColHeader2", resourceCulture);
    1392             }
    1393         }
    1394        
    1395         /// <summary>
    1396         ///   Sucht eine lokalisierte Zeichenfolge, die Resultbit ähnelt.
    1397         /// </summary>
    1398         public static string Tutorial1IntroductionSlide1DataColHeader3 {
    1399             get {
    1400                 return ResourceManager.GetString("Tutorial1IntroductionSlide1DataColHeader3", resourceCulture);
    1401             }
    1402         }
    1403        
    1404         /// <summary>
    1405         ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
    1406         /// </summary>
    1407         public static string Tutorial1IntroductionSlide1Header {
    1408             get {
    1409                 return ResourceManager.GetString("Tutorial1IntroductionSlide1Header", resourceCulture);
    1410             }
    1411         }
    1412        
    1413         /// <summary>
    1414         ///   Sucht eine lokalisierte Zeichenfolge, die If the XOR operation is performed with a message m and key k, the ciphertext is generated: ähnelt.
    1415         /// </summary>
    1416         public static string Tutorial1IntroductionSlide2Content1 {
    1417             get {
    1418                 return ResourceManager.GetString("Tutorial1IntroductionSlide2Content1", resourceCulture);
    1419             }
    1420         }
    1421        
    1422         /// <summary>
    1423         ///   Sucht eine lokalisierte Zeichenfolge, die The core idea of differential cryptanalysis is now to use the key twice. Let&apos;s look at the impact at this point: ähnelt.
    1424         /// </summary>
    1425         public static string Tutorial1IntroductionSlide2Content2 {
    1426             get {
    1427                 return ResourceManager.GetString("Tutorial1IntroductionSlide2Content2", resourceCulture);
    1428             }
    1429         }
    1430        
    1431         /// <summary>
    1432         ///   Sucht eine lokalisierte Zeichenfolge, die We get back the original message m. The XOR operation is often referred to as the difference operator. This is what we will do in this tutorial. ähnelt.
    1433         /// </summary>
    1434         public static string Tutorial1IntroductionSlide2Content3 {
    1435             get {
    1436                 return ResourceManager.GetString("Tutorial1IntroductionSlide2Content3", resourceCulture);
    1437             }
    1438         }
    1439        
    1440         /// <summary>
    1441         ///   Sucht eine lokalisierte Zeichenfolge, die In reality, ciphers are more extensive, more complicated and do not consist exclusively of key additions. The
    1442         ///differential cryptanalysis is a so called &quot;chosen plaintext attack&quot;, which means the cryptanalyst can select plaintext messages and encrypt them to have matching plaintext/ciphertext pairs. ähnelt.
    1443         /// </summary>
    1444         public static string Tutorial1IntroductionSlide2Content4 {
    1445             get {
    1446                 return ResourceManager.GetString("Tutorial1IntroductionSlide2Content4", resourceCulture);
    1447             }
    1448         }
    1449        
    1450         /// <summary>
    1451         ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
    1452         /// </summary>
    1453         public static string Tutorial1IntroductionSlide2Header {
    1454             get {
    1455                 return ResourceManager.GetString("Tutorial1IntroductionSlide2Header", resourceCulture);
    1456             }
    1457         }
    1458        
    1459         /// <summary>
    1460         ///   Sucht eine lokalisierte Zeichenfolge, die Die Idee des zweimaligen Anwendens des Schlüssels nutzen wir, indem wir Paare von Nachrichten m  ähnelt.
    1461         /// </summary>
    1462         public static string Tutorial1IntroductionSlide3Content1Run11 {
    1463             get {
    1464                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run11", resourceCulture);
     3261        public static string Tutorial3AttackFinishedContent2Run2 {
     3262            get {
     3263                return ResourceManager.GetString("Tutorial3AttackFinishedContent2Run2", resourceCulture);
     3264            }
     3265        }
     3266       
     3267        /// <summary>
     3268        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     3269        /// </summary>
     3270        public static string Tutorial3AttackFinishedContent2Run3 {
     3271            get {
     3272                return ResourceManager.GetString("Tutorial3AttackFinishedContent2Run3", resourceCulture);
     3273            }
     3274        }
     3275       
     3276        /// <summary>
     3277        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     3278        /// </summary>
     3279        public static string Tutorial3AttackFinishedContent2Run4 {
     3280            get {
     3281                return ResourceManager.GetString("Tutorial3AttackFinishedContent2Run4", resourceCulture);
     3282            }
     3283        }
     3284       
     3285        /// <summary>
     3286        ///   Sucht eine lokalisierte Zeichenfolge, die  versucht wiederherzustellen. ähnelt.
     3287        /// </summary>
     3288        public static string Tutorial3AttackFinishedContent2Run5 {
     3289            get {
     3290                return ResourceManager.GetString("Tutorial3AttackFinishedContent2Run5", resourceCulture);
     3291            }
     3292        }
     3293       
     3294        /// <summary>
     3295        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 3 beendet ähnelt.
     3296        /// </summary>
     3297        public static string Tutorial3AttackFinishedHeader {
     3298            get {
     3299                return ResourceManager.GetString("Tutorial3AttackFinishedHeader", resourceCulture);
     3300            }
     3301        }
     3302       
     3303        /// <summary>
     3304        ///   Sucht eine lokalisierte Zeichenfolge, die Im letzten Schritt werden die letzten beiden Rundenschlüssel k ähnelt.
     3305        /// </summary>
     3306        public static string Tutorial3AttackFirstRoundContent1Run1 {
     3307            get {
     3308                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent1Run1", resourceCulture);
    14653309            }
    14663310        }
     
    14693313        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    14703314        /// </summary>
    1471         public static string Tutorial1IntroductionSlide3Content1Run2 {
    1472             get {
    1473                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run2", resourceCulture);
    1474             }
    1475         }
    1476        
    1477         /// <summary>
    1478         ///   Sucht eine lokalisierte Zeichenfolge, die  und m ähnelt.
    1479         /// </summary>
    1480         public static string Tutorial1IntroductionSlide3Content1Run3 {
    1481             get {
    1482                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run3", resourceCulture);
     3315        public static string Tutorial3AttackFirstRoundContent1Run2 {
     3316            get {
     3317                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent1Run2", resourceCulture);
     3318            }
     3319        }
     3320       
     3321        /// <summary>
     3322        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     3323        /// </summary>
     3324        public static string Tutorial3AttackFirstRoundContent1Run3 {
     3325            get {
     3326                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent1Run3", resourceCulture);
     3327            }
     3328        }
     3329       
     3330        /// <summary>
     3331        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     3332        /// </summary>
     3333        public static string Tutorial3AttackFirstRoundContent1Run4 {
     3334            get {
     3335                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent1Run4", resourceCulture);
     3336            }
     3337        }
     3338       
     3339        /// <summary>
     3340        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen. Dieser Angriff läuft analog zu dem Verfahren ab, wie es in Tutorial 1 durchgeführt wurde. ähnelt.
     3341        /// </summary>
     3342        public static string Tutorial3AttackFirstRoundContent1Run5 {
     3343            get {
     3344                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent1Run5", resourceCulture);
     3345            }
     3346        }
     3347       
     3348        /// <summary>
     3349        ///   Sucht eine lokalisierte Zeichenfolge, die Durch einen Klick auf weiter werden die ersten beiden Rundenschlüssel k ähnelt.
     3350        /// </summary>
     3351        public static string Tutorial3AttackFirstRoundContent2Run1 {
     3352            get {
     3353                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent2Run1", resourceCulture);
     3354            }
     3355        }
     3356       
     3357        /// <summary>
     3358        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     3359        /// </summary>
     3360        public static string Tutorial3AttackFirstRoundContent2Run2 {
     3361            get {
     3362                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent2Run2", resourceCulture);
     3363            }
     3364        }
     3365       
     3366        /// <summary>
     3367        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     3368        /// </summary>
     3369        public static string Tutorial3AttackFirstRoundContent2Run3 {
     3370            get {
     3371                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent2Run3", resourceCulture);
     3372            }
     3373        }
     3374       
     3375        /// <summary>
     3376        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     3377        /// </summary>
     3378        public static string Tutorial3AttackFirstRoundContent2Run4 {
     3379            get {
     3380                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent2Run4", resourceCulture);
     3381            }
     3382        }
     3383       
     3384        /// <summary>
     3385        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen. ähnelt.
     3386        /// </summary>
     3387        public static string Tutorial3AttackFirstRoundContent2Run5 {
     3388            get {
     3389                return ResourceManager.GetString("Tutorial3AttackFirstRoundContent2Run5", resourceCulture);
     3390            }
     3391        }
     3392       
     3393        /// <summary>
     3394        ///   Sucht eine lokalisierte Zeichenfolge, die Berechnung der Rundenschlüssel k ähnelt.
     3395        /// </summary>
     3396        public static string Tutorial3AttackFirstRoundHeaderRun1 {
     3397            get {
     3398                return ResourceManager.GetString("Tutorial3AttackFirstRoundHeaderRun1", resourceCulture);
     3399            }
     3400        }
     3401       
     3402        /// <summary>
     3403        ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
     3404        /// </summary>
     3405        public static string Tutorial3AttackFirstRoundHeaderRun2 {
     3406            get {
     3407                return ResourceManager.GetString("Tutorial3AttackFirstRoundHeaderRun2", resourceCulture);
     3408            }
     3409        }
     3410       
     3411        /// <summary>
     3412        ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
     3413        /// </summary>
     3414        public static string Tutorial3AttackFirstRoundHeaderRun3 {
     3415            get {
     3416                return ResourceManager.GetString("Tutorial3AttackFirstRoundHeaderRun3", resourceCulture);
     3417            }
     3418        }
     3419       
     3420        /// <summary>
     3421        ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
     3422        /// </summary>
     3423        public static string Tutorial3AttackFirstRoundHeaderRun4 {
     3424            get {
     3425                return ResourceManager.GetString("Tutorial3AttackFirstRoundHeaderRun4", resourceCulture);
     3426            }
     3427        }
     3428       
     3429        /// <summary>
     3430        ///   Sucht eine lokalisierte Zeichenfolge, die 5. Differenzielle Kryptoanalyse von Chiffre 3 ähnelt.
     3431        /// </summary>
     3432        public static string Tutorial3AttackHeader {
     3433            get {
     3434                return ResourceManager.GetString("Tutorial3AttackHeader", resourceCulture);
     3435            }
     3436        }
     3437       
     3438        /// <summary>
     3439        ///   Sucht eine lokalisierte Zeichenfolge, die An dieser Stelle soll der zweite Rundenschlüssel k ähnelt.
     3440        /// </summary>
     3441        public static string Tutorial3AttackKeyRound2Content1Run1 {
     3442            get {
     3443                return ResourceManager.GetString("Tutorial3AttackKeyRound2Content1Run1", resourceCulture);
    14833444            }
    14843445        }
     
    14873448        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
    14883449        /// </summary>
    1489         public static string Tutorial1IntroductionSlide3Content1Run4 {
    1490             get {
    1491                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run4", resourceCulture);
    1492             }
    1493         }
    1494        
    1495         /// <summary>
    1496         ///   Sucht eine lokalisierte Zeichenfolge, die  betrachen. Dann kann folgendes berechnet werden: ähnelt.
    1497         /// </summary>
    1498         public static string Tutorial1IntroductionSlide3Content1Run5 {
    1499             get {
    1500                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content1Run5", resourceCulture);
    1501             }
    1502         }
    1503        
    1504         /// <summary>
    1505         ///   Sucht eine lokalisierte Zeichenfolge, die It is valid: ähnelt.
    1506         /// </summary>
    1507         public static string Tutorial1IntroductionSlide3Content2 {
    1508             get {
    1509                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content2", resourceCulture);
    1510             }
    1511         }
    1512        
    1513         /// <summary>
    1514         ///   Sucht eine lokalisierte Zeichenfolge, die In words, we get the difference of the plain texts by calculating the difference of the key texts. ähnelt.
    1515         /// </summary>
    1516         public static string Tutorial1IntroductionSlide3Content3 {
    1517             get {
    1518                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Content3", resourceCulture);
    1519             }
    1520         }
    1521        
    1522         /// <summary>
    1523         ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
    1524         /// </summary>
    1525         public static string Tutorial1IntroductionSlide3Header {
    1526             get {
    1527                 return ResourceManager.GetString("Tutorial1IntroductionSlide3Header", resourceCulture);
    1528             }
    1529         }
    1530        
    1531         /// <summary>
    1532         ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis continues in the KeyRecovery component. ähnelt.
    1533         /// </summary>
    1534         public static string Tutorial1LastSlideContent1 {
    1535             get {
    1536                 return ResourceManager.GetString("Tutorial1LastSlideContent1", resourceCulture);
    1537             }
    1538         }
    1539        
    1540         /// <summary>
    1541         ///   Sucht eine lokalisierte Zeichenfolge, die You can now restore the round keys K ähnelt.
    1542         /// </summary>
    1543         public static string Tutorial1LastSlideContent2Run1 {
    1544             get {
    1545                 return ResourceManager.GetString("Tutorial1LastSlideContent2Run1", resourceCulture);
    1546             }
    1547         }
    1548        
    1549         /// <summary>
    1550         ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    1551         /// </summary>
    1552         public static string Tutorial1LastSlideContent2Run2 {
    1553             get {
    1554                 return ResourceManager.GetString("Tutorial1LastSlideContent2Run2", resourceCulture);
    1555             }
    1556         }
    1557        
    1558         /// <summary>
    1559         ///   Sucht eine lokalisierte Zeichenfolge, die  and K ähnelt.
    1560         /// </summary>
    1561         public static string Tutorial1LastSlideContent2Run3 {
    1562             get {
    1563                 return ResourceManager.GetString("Tutorial1LastSlideContent2Run3", resourceCulture);
    1564             }
    1565         }
    1566        
    1567         /// <summary>
    1568         ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
    1569         /// </summary>
    1570         public static string Tutorial1LastSlideContent2Run4 {
    1571             get {
    1572                 return ResourceManager.GetString("Tutorial1LastSlideContent2Run4", resourceCulture);
    1573             }
    1574         }
    1575        
    1576         /// <summary>
    1577         ///   Sucht eine lokalisierte Zeichenfolge, die  in the KeyRecovery component using differential cryptanalysis. The attack is as described above. ähnelt.
    1578         /// </summary>
    1579         public static string Tutorial1LastSlideContent2Run5 {
    1580             get {
    1581                 return ResourceManager.GetString("Tutorial1LastSlideContent2Run5", resourceCulture);
    1582             }
    1583         }
    1584        
    1585         /// <summary>
    1586         ///   Sucht eine lokalisierte Zeichenfolge, die To do this, you must click the Start button in the KeyRecovery component. ähnelt.
    1587         /// </summary>
    1588         public static string Tutorial1LastSlideContent3 {
    1589             get {
    1590                 return ResourceManager.GetString("Tutorial1LastSlideContent3", resourceCulture);
    1591             }
    1592         }
    1593        
    1594         /// <summary>
    1595         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 1 finished ähnelt.
    1596         /// </summary>
    1597         public static string Tutorial1LastSlideHeader {
    1598             get {
    1599                 return ResourceManager.GetString("Tutorial1LastSlideHeader", resourceCulture);
    1600             }
    1601         }
    1602        
    1603         /// <summary>
    1604         ///   Sucht eine lokalisierte Zeichenfolge, die 3. Execution of differential cryptanalysis ähnelt.
    1605         /// </summary>
    1606         public static string Tutorial1PracticalDifferentialCryptanalysisHeader {
    1607             get {
    1608                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisHeader", resourceCulture);
    1609             }
    1610         }
    1611        
    1612         /// <summary>
    1613         ///   Sucht eine lokalisierte Zeichenfolge, die Es werden die letzten beiden Rundenschlüssel k ähnelt.
    1614         /// </summary>
    1615         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run1 {
    1616             get {
    1617                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run1", resourceCulture);
    1618             }
    1619         }
    1620        
    1621         /// <summary>
    1622         ///   Sucht eine lokalisierte Zeichenfolge, die 1 ähnelt.
    1623         /// </summary>
    1624         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run2 {
    1625             get {
    1626                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run2", resourceCulture);
    1627             }
    1628         }
    1629        
    1630         /// <summary>
    1631         ///   Sucht eine lokalisierte Zeichenfolge, die  und k ähnelt.
    1632         /// </summary>
    1633         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run3 {
    1634             get {
    1635                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run3", resourceCulture);
    1636             }
    1637         }
    1638        
    1639         /// <summary>
    1640         ///   Sucht eine lokalisierte Zeichenfolge, die 0 ähnelt.
    1641         /// </summary>
    1642         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run4 {
    1643             get {
    1644                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run4", resourceCulture);
    1645             }
    1646         }
    1647        
    1648         /// <summary>
    1649         ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen. Der Angriff verläuft wie in diesem Tutorial vorgestellt wurde. ähnelt.
    1650         /// </summary>
    1651         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run5 {
    1652             get {
    1653                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content1Run5", resourceCulture);
    1654             }
    1655         }
    1656        
    1657         /// <summary>
    1658         ///   Sucht eine lokalisierte Zeichenfolge, die Click on continue to start the attack. ähnelt.
    1659         /// </summary>
    1660         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Content2 {
    1661             get {
    1662                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Content2", resourceCulture);
    1663             }
    1664         }
    1665        
    1666         /// <summary>
    1667         ///   Sucht eine lokalisierte Zeichenfolge, die Execution of differential cryptanalysis ähnelt.
    1668         /// </summary>
    1669         public static string Tutorial1PracticalDifferentialCryptanalysisSlide1Header {
    1670             get {
    1671                 return ResourceManager.GetString("Tutorial1PracticalDifferentialCryptanalysisSlide1Header", resourceCulture);
    1672             }
    1673         }
    1674        
    1675         /// <summary>
    1676         ///   Sucht eine lokalisierte Zeichenfolge, die 2. Analysis of Cipher 2 ähnelt.
    1677         /// </summary>
    1678         public static string Tutorial2AnalysisHeader {
    1679             get {
    1680                 return ResourceManager.GetString("Tutorial2AnalysisHeader", resourceCulture);
    1681             }
    1682         }
    1683        
    1684         /// <summary>
    1685         ///   Sucht eine lokalisierte Zeichenfolge, die 3. Analysis of the SBoxes ähnelt.
    1686         /// </summary>
    1687         public static string Tutorial2AnalysisOfSBoxHeader {
    1688             get {
    1689                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxHeader", resourceCulture);
    1690             }
    1691         }
    1692        
    1693         /// <summary>
    1694         ///   Sucht eine lokalisierte Zeichenfolge, die Due to the key addition, the SBox behaves non-linear. A guess attempt for K3 cannot be checked directly. ähnelt.
    1695         /// </summary>
    1696         public static string Tutorial2AnalysisOfSBoxSlide1Content1 {
    1697             get {
    1698                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content1", resourceCulture);
    1699             }
    1700         }
    1701        
    1702         /// <summary>
    1703         ///   Sucht eine lokalisierte Zeichenfolge, die All SBoxes of cipher 2 behave identically. For this reason it is sufficient to analyze the functionality of a single SBox. Basically it is possible to consider 4 parallel SBoxes as one big SBox, but this would increase the analysis complexity. The SBox receives 4 bits as input and also outputs 4 bits as output. The 4 input bits are replaced by 4 other output bits. ähnelt.
    1704         /// </summary>
    1705         public static string Tutorial2AnalysisOfSBoxSlide1Content2 {
    1706             get {
    1707                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content2", resourceCulture);
    1708             }
    1709         }
    1710        
    1711         /// <summary>
    1712         ///   Sucht eine lokalisierte Zeichenfolge, die Remember: Differential cryptanalysis works with differences of messages. In order to examine the SBox, all combinations of input plaintext are considered and their differences are calculated. For each pair, the plain texts are given individually into the SBox and then the difference of the substituted outputs is calculated. The transitions from input to output difference are noted. ähnelt.
    1713         /// </summary>
    1714         public static string Tutorial2AnalysisOfSBoxSlide1Content3 {
    1715             get {
    1716                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content3", resourceCulture);
    1717             }
    1718         }
    1719        
    1720         /// <summary>
    1721         ///   Sucht eine lokalisierte Zeichenfolge, die The table on the next page visualizes this procedure. There is one line for each possible input difference. There is one column for each possible output difference. The number of occurrences of a particular difference is described by the entries in the table. ähnelt.
    1722         /// </summary>
    1723         public static string Tutorial2AnalysisOfSBoxSlide1Content4 {
    1724             get {
    1725                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content4", resourceCulture);
    1726             }
    1727         }
    1728        
    1729         /// <summary>
    1730         ///   Sucht eine lokalisierte Zeichenfolge, die To calculate the probability of a difference occurring, the number must be divided by 16. ähnelt.
    1731         /// </summary>
    1732         public static string Tutorial2AnalysisOfSBoxSlide1Content5 {
    1733             get {
    1734                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Content5", resourceCulture);
    1735             }
    1736         }
    1737        
    1738         /// <summary>
    1739         ///   Sucht eine lokalisierte Zeichenfolge, die Analysis of the SBoxes ähnelt.
    1740         /// </summary>
    1741         public static string Tutorial2AnalysisOfSBoxSlide1Header {
    1742             get {
    1743                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide1Header", resourceCulture);
    1744             }
    1745         }
    1746        
    1747         /// <summary>
    1748         ///   Sucht eine lokalisierte Zeichenfolge, die The difference distribution table is shown below: ähnelt.
    1749         /// </summary>
    1750         public static string Tutorial2AnalysisOfSBoxSlide2Content1 {
    1751             get {
    1752                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2Content1", resourceCulture);
    1753             }
    1754         }
    1755        
    1756         /// <summary>
    1757         ///   Sucht eine lokalisierte Zeichenfolge, die Analysis of the SBoxes ähnelt.
    1758         /// </summary>
    1759         public static string Tutorial2AnalysisOfSBoxSlide2Header {
    1760             get {
    1761                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2Header", resourceCulture);
    1762             }
    1763         }
    1764        
    1765         /// <summary>
    1766         ///   Sucht eine lokalisierte Zeichenfolge, die Input difference ähnelt.
    1767         /// </summary>
    1768         public static string Tutorial2AnalysisOfSBoxSlide2InputDifference {
    1769             get {
    1770                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2InputDifference", resourceCulture);
    1771             }
    1772         }
    1773        
    1774         /// <summary>
    1775         ///   Sucht eine lokalisierte Zeichenfolge, die Output difference ähnelt.
    1776         /// </summary>
    1777         public static string Tutorial2AnalysisOfSBoxSlide2OutputDifference {
    1778             get {
    1779                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide2OutputDifference", resourceCulture);
    1780             }
    1781         }
    1782        
    1783         /// <summary>
    1784         ///   Sucht eine lokalisierte Zeichenfolge, die The table is called the difference distribution table. The input and output differences are hexadecimal. ähnelt.
    1785         /// </summary>
    1786         public static string Tutorial2AnalysisOfSBoxSlide3Content1 {
    1787             get {
    1788                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content1", resourceCulture);
    1789             }
    1790         }
    1791        
    1792         /// <summary>
    1793         ///   Sucht eine lokalisierte Zeichenfolge, die A 4 Bit SBox has 16 different inputs and 16 different outputs. If 2 messages are combined to a message pair with disjunct differences, 256 different transitions of differences can be observed. ähnelt.
    1794         /// </summary>
    1795         public static string Tutorial2AnalysisOfSBoxSlide3Content2 {
    1796             get {
    1797                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content2", resourceCulture);
    1798             }
    1799         }
    1800        
    1801         /// <summary>
    1802         ///   Sucht eine lokalisierte Zeichenfolge, die An important observation is that there are differences that occur more frequently than others. There are also differences that do not occur at all. For example, the input difference 8 is mapped to the output difference D 8 times. ähnelt.
    1803         /// </summary>
    1804         public static string Tutorial2AnalysisOfSBoxSlide3Content3 {
    1805             get {
    1806                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content3", resourceCulture);
    1807             }
    1808         }
    1809        
    1810         /// <summary>
    1811         ///   Sucht eine lokalisierte Zeichenfolge, die The distribution of differences is obviously not uniform. In practice, SBoxes are not perfect. The cryptanalyst makes use of this fact. Particularly high probabilities help with differential cryptanalysis. ähnelt.
    1812         /// </summary>
    1813         public static string Tutorial2AnalysisOfSBoxSlide3Content4 {
    1814             get {
    1815                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Content4", resourceCulture);
    1816             }
    1817         }
    1818        
    1819         /// <summary>
    1820         ///   Sucht eine lokalisierte Zeichenfolge, die Analysis of the SBoxes ähnelt.
    1821         /// </summary>
    1822         public static string Tutorial2AnalysisOfSBoxSlide3Header {
    1823             get {
    1824                 return ResourceManager.GetString("Tutorial2AnalysisOfSBoxSlide3Header", resourceCulture);
    1825             }
    1826         }
    1827        
    1828         /// <summary>
    1829         ///   Sucht eine lokalisierte Zeichenfolge, die Cipher 2 consists of three encryption rounds with four round keys. Each round consists of key addition, substitution and permutation. In the last round an additional key addition is performed. ähnelt.
    1830         /// </summary>
    1831         public static string Tutorial2AnalysisSlide1Content1 {
    1832             get {
    1833                 return ResourceManager.GetString("Tutorial2AnalysisSlide1Content1", resourceCulture);
    1834             }
    1835         }
    1836        
    1837         /// <summary>
    1838         ///   Sucht eine lokalisierte Zeichenfolge, die A permutation is also used in this cipher. This permutation exchanges the bit positions of the block. In the schema the permutation is called P(). In addition to the internal states u and v, w is introduced. This state represents the value after a permutation. ähnelt.
    1839         /// </summary>
    1840         public static string Tutorial2AnalysisSlide1Content3 {
    1841             get {
    1842                 return ResourceManager.GetString("Tutorial2AnalysisSlide1Content3", resourceCulture);
    1843             }
    1844         }
    1845        
    1846         /// <summary>
    1847         ///   Sucht eine lokalisierte Zeichenfolge, die Analysis of Cipher 2 ähnelt.
    1848         /// </summary>
    1849         public static string Tutorial2AnalysisSlide1Header {
    1850             get {
    1851                 return ResourceManager.GetString("Tutorial2AnalysisSlide1Header", resourceCulture);
    1852             }
    1853         }
    1854        
    1855         /// <summary>
    1856         ///   Sucht eine lokalisierte Zeichenfolge, die Analysis of Cipher 2 ähnelt.
    1857         /// </summary>
    1858         public static string Tutorial2AnalysisSlide2Header {
    1859             get {
    1860                 return ResourceManager.GetString("Tutorial2AnalysisSlide2Header", resourceCulture);
    1861             }
    1862         }
    1863        
    1864         /// <summary>
    1865         ///   Sucht eine lokalisierte Zeichenfolge, die You could now try to attack the keys of cipher 2 in a similar way to attack cipher 1. However, it is not possible to check a guess for K3, because cipher 2 has more internal states due to the number of rounds. For this reason the functionality of the SBoxes must be examined. ähnelt.
    1866         /// </summary>
    1867         public static string Tutorial2AnalysisSlide3Content1 {
    1868             get {
    1869                 return ResourceManager.GetString("Tutorial2AnalysisSlide3Content1", resourceCulture);
    1870             }
    1871         }
    1872        
    1873         /// <summary>
    1874         ///   Sucht eine lokalisierte Zeichenfolge, die Analysis of Cipher 2 ähnelt.
    1875         /// </summary>
    1876         public static string Tutorial2AnalysisSlide3Header {
    1877             get {
    1878                 return ResourceManager.GetString("Tutorial2AnalysisSlide3Header", resourceCulture);
    1879             }
    1880         }
    1881        
    1882         /// <summary>
    1883         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2 on differential cryptanalysis in the DCA PathFinder component is finished. All key bits were attacked. ähnelt.
    1884         /// </summary>
    1885         public static string Tutorial2AttackFinishedContent1 {
    1886             get {
    1887                 return ResourceManager.GetString("Tutorial2AttackFinishedContent1", resourceCulture);
    1888             }
    1889         }
    1890        
    1891         /// <summary>
    1892         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial 2 finished ähnelt.
    1893         /// </summary>
    1894         public static string Tutorial2AttackFinishedHeader {
    1895             get {
    1896                 return ResourceManager.GetString("Tutorial2AttackFinishedHeader", resourceCulture);
    1897             }
    1898         }
    1899        
    1900         /// <summary>
    1901         ///   Sucht eine lokalisierte Zeichenfolge, die In the last step, the last two round keys K1 and K0 are attacked. This attack is identical to the procedure described in Tutorial 1. ähnelt.
    1902         /// </summary>
    1903         public static string Tutorial2AttackFirstRoundContent1 {
    1904             get {
    1905                 return ResourceManager.GetString("Tutorial2AttackFirstRoundContent1", resourceCulture);
    1906             }
    1907         }
    1908        
    1909         /// <summary>
    1910         ///   Sucht eine lokalisierte Zeichenfolge, die Click on continue to attack the first two round keys. ähnelt.
    1911         /// </summary>
    1912         public static string Tutorial2AttackFirstRoundContent2 {
    1913             get {
    1914                 return ResourceManager.GetString("Tutorial2AttackFirstRoundContent2", resourceCulture);
    1915             }
    1916         }
    1917        
    1918         /// <summary>
    1919         ///   Sucht eine lokalisierte Zeichenfolge, die Calculation of round keys K1 and K0 ähnelt.
    1920         /// </summary>
    1921         public static string Tutorial2AttackFirstRoundHeader {
    1922             get {
    1923                 return ResourceManager.GetString("Tutorial2AttackFirstRoundHeader", resourceCulture);
    1924             }
    1925         }
    1926        
    1927         /// <summary>
    1928         ///   Sucht eine lokalisierte Zeichenfolge, die 7. Differential cryptanalysis of cipher 2 ähnelt.
    1929         /// </summary>
    1930         public static string Tutorial2AttackHeader {
    1931             get {
    1932                 return ResourceManager.GetString("Tutorial2AttackHeader", resourceCulture);
    1933             }
    1934         }
    1935        
    1936         /// <summary>
    1937         ///   Sucht eine lokalisierte Zeichenfolge, die At this point, the second round key K ähnelt.
    1938         /// </summary>
    1939         public static string Tutorial2AttackKeyRound2Content1Run1 {
    1940             get {
    1941                 return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run1", resourceCulture);
     3450        public static string Tutorial3AttackKeyRound2Content1Run2 {
     3451            get {
     3452                return ResourceManager.GetString("Tutorial3AttackKeyRound2Content1Run2", resourceCulture);
     3453            }
     3454        }
     3455       
     3456        /// <summary>
     3457        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen werden. Dazu können in der zweiten Verschlüsselungsrunde SBoxen ausgewählt werden. Durch die Auswahl einer SBox werden die jeweiligen 4 Bits des Rundenschlüssels angegriffen und versucht wiederherzustellen. ähnelt.
     3458        /// </summary>
     3459        public static string Tutorial3AttackKeyRound2Content1Run3 {
     3460            get {
     3461                return ResourceManager.GetString("Tutorial3AttackKeyRound2Content1Run3", resourceCulture);
     3462            }
     3463        }
     3464       
     3465        /// <summary>
     3466        ///   Sucht eine lokalisierte Zeichenfolge, die Der Angriff läuft nahezu analog zu dem auf den Rundenschlüssel k ähnelt.
     3467        /// </summary>
     3468        public static string Tutorial3AttackKeyRound2Content1Run4 {
     3469            get {
     3470                return ResourceManager.GetString("Tutorial3AttackKeyRound2Content1Run4", resourceCulture);
     3471            }
     3472        }
     3473       
     3474        /// <summary>
     3475        ///   Sucht eine lokalisierte Zeichenfolge, die 5 ähnelt.
     3476        /// </summary>
     3477        public static string Tutorial3AttackKeyRound2Content1Run5 {
     3478            get {
     3479                return ResourceManager.GetString("Tutorial3AttackKeyRound2Content1Run5", resourceCulture);
     3480            }
     3481        }
     3482       
     3483        /// <summary>
     3484        ///   Sucht eine lokalisierte Zeichenfolge, die  ab. Allerdings muss bei der Suche nach Differenzialen die Chiffre nicht mehr so tief durchsucht werden, da bereits eine Verschlüsselungsrunde vollständig angegriffen wurde. ähnelt.
     3485        /// </summary>
     3486        public static string Tutorial3AttackKeyRound2Content1Run6 {
     3487            get {
     3488                return ResourceManager.GetString("Tutorial3AttackKeyRound2Content1Run6", resourceCulture);
     3489            }
     3490        }
     3491       
     3492        /// <summary>
     3493        ///   Sucht eine lokalisierte Zeichenfolge, die An dieser Stelle soll der zweite Rundenschlüssel k ähnelt.
     3494        /// </summary>
     3495        public static string Tutorial3AttackKeyRound3Content1Run1 {
     3496            get {
     3497                return ResourceManager.GetString("Tutorial3AttackKeyRound3Content1Run1", resourceCulture);
     3498            }
     3499        }
     3500       
     3501        /// <summary>
     3502        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
     3503        /// </summary>
     3504        public static string Tutorial3AttackKeyRound3Content1Run2 {
     3505            get {
     3506                return ResourceManager.GetString("Tutorial3AttackKeyRound3Content1Run2", resourceCulture);
     3507            }
     3508        }
     3509       
     3510        /// <summary>
     3511        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen werden. Dazu können in der zweiten Verschlüsselungsrunde SBoxen ausgewählt werden. Durch die Auswahl einer SBox werden die jeweiligen 4 Bits des Rundenschlüssels angegriffen und versucht wiederherzustellen. ähnelt.
     3512        /// </summary>
     3513        public static string Tutorial3AttackKeyRound3Content1Run3 {
     3514            get {
     3515                return ResourceManager.GetString("Tutorial3AttackKeyRound3Content1Run3", resourceCulture);
     3516            }
     3517        }
     3518       
     3519        /// <summary>
     3520        ///   Sucht eine lokalisierte Zeichenfolge, die Der Angriff läuft nahezu analog zu dem auf den Rundenschlüssel k ähnelt.
     3521        /// </summary>
     3522        public static string Tutorial3AttackKeyRound3Content1Run4 {
     3523            get {
     3524                return ResourceManager.GetString("Tutorial3AttackKeyRound3Content1Run4", resourceCulture);
     3525            }
     3526        }
     3527       
     3528        /// <summary>
     3529        ///   Sucht eine lokalisierte Zeichenfolge, die 5 ähnelt.
     3530        /// </summary>
     3531        public static string Tutorial3AttackKeyRound3Content1Run5 {
     3532            get {
     3533                return ResourceManager.GetString("Tutorial3AttackKeyRound3Content1Run5", resourceCulture);
     3534            }
     3535        }
     3536       
     3537        /// <summary>
     3538        ///   Sucht eine lokalisierte Zeichenfolge, die  ab. Allerdings muss bei der Suche nach Differenzialen die Chiffre nicht mehr so tief durchsucht werden, da bereits eine Verschlüsselungsrunde vollständig angegriffen wurde. ähnelt.
     3539        /// </summary>
     3540        public static string Tutorial3AttackKeyRound3Content1Run6 {
     3541            get {
     3542                return ResourceManager.GetString("Tutorial3AttackKeyRound3Content1Run6", resourceCulture);
     3543            }
     3544        }
     3545       
     3546        /// <summary>
     3547        ///   Sucht eine lokalisierte Zeichenfolge, die An dieser Stelle soll der zweite Rundenschlüssel k ähnelt.
     3548        /// </summary>
     3549        public static string Tutorial3AttackKeyRound4Content1Run1 {
     3550            get {
     3551                return ResourceManager.GetString("Tutorial3AttackKeyRound4Content1Run1", resourceCulture);
     3552            }
     3553        }
     3554       
     3555        /// <summary>
     3556        ///   Sucht eine lokalisierte Zeichenfolge, die 4 ähnelt.
     3557        /// </summary>
     3558        public static string Tutorial3AttackKeyRound4Content1Run2 {
     3559            get {
     3560                return ResourceManager.GetString("Tutorial3AttackKeyRound4Content1Run2", resourceCulture);
     3561            }
     3562        }
     3563       
     3564        /// <summary>
     3565        ///   Sucht eine lokalisierte Zeichenfolge, die  angegriffen werden. Dazu können in der zweiten Verschlüsselungsrunde SBoxen ausgewählt werden. Durch die Auswahl einer SBox werden die jeweiligen 4 Bits des Rundenschlüssels angegriffen und versucht wiederherzustellen. ähnelt.
     3566        /// </summary>
     3567        public static string Tutorial3AttackKeyRound4Content1Run3 {
     3568            get {
     3569                return ResourceManager.GetString("Tutorial3AttackKeyRound4Content1Run3", resourceCulture);
     3570            }
     3571        }
     3572       
     3573        /// <summary>
     3574        ///   Sucht eine lokalisierte Zeichenfolge, die Der Angriff läuft nahezu analog zu dem auf den Rundenschlüssel k ähnelt.
     3575        /// </summary>
     3576        public static string Tutorial3AttackKeyRound4Content1Run4 {
     3577            get {
     3578                return ResourceManager.GetString("Tutorial3AttackKeyRound4Content1Run4", resourceCulture);
     3579            }
     3580        }
     3581       
     3582        /// <summary>
     3583        ///   Sucht eine lokalisierte Zeichenfolge, die 5 ähnelt.
     3584        /// </summary>
     3585        public static string Tutorial3AttackKeyRound4Content1Run5 {
     3586            get {
     3587                return ResourceManager.GetString("Tutorial3AttackKeyRound4Content1Run5", resourceCulture);
     3588            }
     3589        }
     3590       
     3591        /// <summary>
     3592        ///   Sucht eine lokalisierte Zeichenfolge, die  ab. Allerdings muss bei der Suche nach Differenzialen die Chiffre nicht mehr so tief durchsucht werden, da bereits eine Verschlüsselungsrunde vollständig angegriffen wurde. ähnelt.
     3593        /// </summary>
     3594        public static string Tutorial3AttackKeyRound4Content1Run6 {
     3595            get {
     3596                return ResourceManager.GetString("Tutorial3AttackKeyRound4Content1Run6", resourceCulture);
     3597            }
     3598        }
     3599       
     3600        /// <summary>
     3601        ///   Sucht eine lokalisierte Zeichenfolge, die An dieser Stelle soll der erste Rundenschlüssel k ähnelt.
     3602        /// </summary>
     3603        public static string Tutorial3AttackKeyRound5Content1Run1 {
     3604            get {
     3605                return ResourceManager.GetString("Tutorial3AttackKeyRound5Content1Run1", resourceCulture);
     3606            }
     3607        }
     3608       
     3609        /// <summary>
     3610        ///   Sucht eine lokalisierte Zeichenfolge, die 5 ähnelt.
     3611        /// </summary>
     3612        public static string Tutorial3AttackKeyRound5Content1Run2 {
     3613            get {
     3614                return ResourceManager.GetString("Tutorial3AttackKeyRound5Content1Run2", resourceCulture);
     3615            }
     3616        }
     3617       
     3618        /// <summary>
     3619        ///   Sucht eine lokalisierte Zeichenfolge, die  der Chiffre angegriffen werden. Dazu können in der fünften Verschlüsselungsrunde SBoxen ausgewählt werden. Durch die Auswahl einer SBox werden die jeweiligen 4 Bits des Rundenschlüssels angegriffen und versucht wiederherzustellen. ähnelt.
     3620        /// </summary>
     3621        public static string Tutorial3AttackKeyRound5Content1Run3 {
     3622            get {
     3623                return ResourceManager.GetString("Tutorial3AttackKeyRound5Content1Run3", resourceCulture);
     3624            }
     3625        }
     3626       
     3627        /// <summary>
     3628        ///   Sucht eine lokalisierte Zeichenfolge, die Bei der differenziellen Kryptoanalyse wird die Veränderung von Differenzen an den SBoxen betrachtet. Daher sind an dieser Stelle SBoxen auszuwählen. ähnelt.
     3629        /// </summary>
     3630        public static string Tutorial3AttackKeyRound5Content1Run4 {
     3631            get {
     3632                return ResourceManager.GetString("Tutorial3AttackKeyRound5Content1Run4", resourceCulture);
     3633            }
     3634        }
     3635       
     3636        /// <summary>
     3637        ///   Sucht eine lokalisierte Zeichenfolge, die Je mehr Schlüsselbits ausgewählt werden, desto komplizierter ist die Suche nach einem Differenzial. Allerdings kann durchaus sinnvoll sein, mehrere SBoxen gleichzeitig anzugreifen. Je nach Beschaffenheit der Chiffre finden sich so bessere oder schlechtere Differenziale. ähnelt.
     3638        /// </summary>
     3639        public static string Tutorial3AttackKeyRound5Content1Run5 {
     3640            get {
     3641                return ResourceManager.GetString("Tutorial3AttackKeyRound5Content1Run5", resourceCulture);
     3642            }
     3643        }
     3644       
     3645        /// <summary>
     3646        ///   Sucht eine lokalisierte Zeichenfolge, die SBoxen aus Runde 2 auswählen, um Schlüsselbits von k ähnelt.
     3647        /// </summary>
     3648        public static string Tutorial3AttackRound2HeaderRun1 {
     3649            get {
     3650                return ResourceManager.GetString("Tutorial3AttackRound2HeaderRun1", resourceCulture);
    19423651            }
    19433652        }
     
    19463655        ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
    19473656        /// </summary>
    1948         public static string Tutorial2AttackKeyRound2Content1Run2 {
    1949             get {
    1950                 return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run2", resourceCulture);
    1951             }
    1952         }
    1953        
    1954         /// <summary>
    1955         ///   Sucht eine lokalisierte Zeichenfolge, die  is to be attacked. SBoxes can be selected for this in the second encryption round. By selecting an SBox, the respective 4 bits of the round key are attacked and an attempt is made to restore them. ähnelt.
    1956         /// </summary>
    1957         public static string Tutorial2AttackKeyRound2Content1Run3 {
    1958             get {
    1959                 return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run3", resourceCulture);
    1960             }
    1961         }
    1962        
    1963         /// <summary>
    1964         ///   Sucht eine lokalisierte Zeichenfolge, die The attack is almost analogous to the one on the K ähnelt.
    1965         /// </summary>
    1966         public static string Tutorial2AttackKeyRound2Content1Run4 {
    1967             get {
    1968                 return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run4", resourceCulture);
     3657        public static string Tutorial3AttackRound2HeaderRun2 {
     3658            get {
     3659                return ResourceManager.GetString("Tutorial3AttackRound2HeaderRun2", resourceCulture);
     3660            }
     3661        }
     3662       
     3663        /// <summary>
     3664        ///   Sucht eine lokalisierte Zeichenfolge, die  anzugreifen ähnelt.
     3665        /// </summary>
     3666        public static string Tutorial3AttackRound2HeaderRun3 {
     3667            get {
     3668                return ResourceManager.GetString("Tutorial3AttackRound2HeaderRun3", resourceCulture);
     3669            }
     3670        }
     3671       
     3672        /// <summary>
     3673        ///   Sucht eine lokalisierte Zeichenfolge, die SBoxen aus Runde 3 auswählen, um Schlüsselbits von k ähnelt.
     3674        /// </summary>
     3675        public static string Tutorial3AttackRound3HeaderRun1 {
     3676            get {
     3677                return ResourceManager.GetString("Tutorial3AttackRound3HeaderRun1", resourceCulture);
    19693678            }
    19703679        }
     
    19733682        ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
    19743683        /// </summary>
    1975         public static string Tutorial2AttackKeyRound2Content1Run5 {
    1976             get {
    1977                 return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run5", resourceCulture);
    1978             }
    1979         }
    1980        
    1981         /// <summary>
    1982         ///   Sucht eine lokalisierte Zeichenfolge, die  round key. However, when searching for differentials, the cipher does not have to be searched so deeply any more, since an encryption round has already been completely attacked. ähnelt.
    1983         /// </summary>
    1984         public static string Tutorial2AttackKeyRound2Content1Run6 {
    1985             get {
    1986                 return ResourceManager.GetString("Tutorial2AttackKeyRound2Content1Run6", resourceCulture);
    1987             }
    1988         }
    1989        
    1990         /// <summary>
    1991         ///   Sucht eine lokalisierte Zeichenfolge, die At this point, the first round key K ähnelt.
    1992         /// </summary>
    1993         public static string Tutorial2AttackKeyRound3Content1Run1 {
    1994             get {
    1995                 return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run1", resourceCulture);
    1996             }
    1997         }
    1998        
    1999         /// <summary>
    2000         ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
    2001         /// </summary>
    2002         public static string Tutorial2AttackKeyRound3Content1Run2 {
    2003             get {
    2004                 return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run2", resourceCulture);
    2005             }
    2006         }
    2007        
    2008         /// <summary>
    2009         ///   Sucht eine lokalisierte Zeichenfolge, die  of the cipher is to be attacked. SBoxes can be selected for this in the third encryption round. By selecting an SBox the respective 4 bits of the round key are attacked and an attempt is made to restore them. ähnelt.
    2010         /// </summary>
    2011         public static string Tutorial2AttackKeyRound3Content1Run3 {
    2012             get {
    2013                 return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run3", resourceCulture);
    2014             }
    2015         }
    2016        
    2017         /// <summary>
    2018         ///   Sucht eine lokalisierte Zeichenfolge, die In differential cryptanalysis, the change of differences at the SBoxes is observed. SBoxes should therefore be selected at this point. ähnelt.
    2019         /// </summary>
    2020         public static string Tutorial2AttackKeyRound3Content1Run4 {
    2021             get {
    2022                 return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run4", resourceCulture);
    2023             }
    2024         }
    2025        
    2026         /// <summary>
    2027         ///   Sucht eine lokalisierte Zeichenfolge, die The more key bits that are selected, the more complicated the search for a differential. However, it can make sense to attack several SBoxes at the same time. Depending on the properties of the cipher, better or worse differentials can be found. ähnelt.
    2028         /// </summary>
    2029         public static string Tutorial2AttackKeyRound3Content1Run5 {
    2030             get {
    2031                 return ResourceManager.GetString("Tutorial2AttackKeyRound3Content1Run5", resourceCulture);
    2032             }
    2033         }
    2034        
    2035         /// <summary>
    2036         ///   Sucht eine lokalisierte Zeichenfolge, die Select SBoxes from round 2 to attack key bits from K ähnelt.
    2037         /// </summary>
    2038         public static string Tutorial2AttackRound2HeaderRun1 {
    2039             get {
    2040                 return ResourceManager.GetString("Tutorial2AttackRound2HeaderRun1", resourceCulture);
    2041             }
    2042         }
    2043        
    2044         /// <summary>
    2045         ///   Sucht eine lokalisierte Zeichenfolge, die 2 ähnelt.
    2046         /// </summary>
    2047         public static string Tutorial2AttackRound2HeaderRun2 {
    2048             get {
    2049                 return ResourceManager.GetString("Tutorial2AttackRound2HeaderRun2", resourceCulture);
    2050             }
    2051         }
    2052        
    2053         /// <summary>
    2054         ///   Sucht eine lokalisierte Zeichenfolge, die  ähnelt.
    2055         /// </summary>
    2056         public static string Tutorial2AttackRound2HeaderRun3 {
    2057             get {
    2058                 return ResourceManager.GetString("Tutorial2AttackRound2HeaderRun3", resourceCulture);
    2059             }
    2060         }
    2061        
    2062         /// <summary>
    2063         ///   Sucht eine lokalisierte Zeichenfolge, die Select SBoxes from round 3 to attack key bits from K ähnelt.
    2064         /// </summary>
    2065         public static string Tutorial2AttackRound3HeaderRun1 {
    2066             get {
    2067                 return ResourceManager.GetString("Tutorial2AttackRound3HeaderRun1", resourceCulture);
    2068             }
    2069         }
    2070        
    2071         /// <summary>
    2072         ///   Sucht eine lokalisierte Zeichenfolge, die 3 ähnelt.
    2073         /// </summary>
    2074         public static string Tutorial2AttackRound3HeaderRun2 {
    2075             get {
    2076                 return ResourceManager.GetString("Tutorial2AttackRound3HeaderRun2", resourceCulture);
    2077             }
    2078         }
    2079        
    2080         /// <summary>
    2081         ///   Sucht eine lokalisierte Zeichenfolge, die  ähnelt.
    2082         /// </summary>
    2083         public static string Tutorial2AttackRound3HeaderRun3 {
    2084             get {
    2085                 return ResourceManager.GetString("Tutorial2AttackRound3HeaderRun3", resourceCulture);
    2086             }
    2087         }
    2088        
    2089         /// <summary>
    2090         ///   Sucht eine lokalisierte Zeichenfolge, die 4. Characteristics ähnelt.
    2091         /// </summary>
    2092         public static string Tutorial2CharacteristicHeader {
    2093             get {
    2094                 return ResourceManager.GetString("Tutorial2CharacteristicHeader", resourceCulture);
    2095             }
    2096         }
    2097        
    2098         /// <summary>
    2099         ///   Sucht eine lokalisierte Zeichenfolge, die Differentials are... ähnelt.
    2100         /// </summary>
    2101         public static string Tutorial2CharacteristicSlide1Content1 {
    2102             get {
    2103                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1", resourceCulture);
    2104             }
    2105         }
    2106        
    2107         /// <summary>
    2108         ///   Sucht eine lokalisierte Zeichenfolge, die Zwei Eingaben, die sich durch eine Differenz  ähnelt.
    2109         /// </summary>
    2110         public static string Tutorial2CharacteristicSlide1Content1Run1 {
    2111             get {
    2112                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1Run1", resourceCulture);
    2113             }
    2114         }
    2115        
    2116         /// <summary>
    2117         ///   Sucht eine lokalisierte Zeichenfolge, die  unterscheiden, werden unter Verwendung der SBox durch ein Paar von Ausgaben substitutiert, welche sich durch eine Differenz  ähnelt.
    2118         /// </summary>
    2119         public static string Tutorial2CharacteristicSlide1Content1Run2 {
    2120             get {
    2121                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1Run2", resourceCulture);
    2122             }
    2123         }
    2124        
    2125         /// <summary>
    2126         ///   Sucht eine lokalisierte Zeichenfolge, die  unterscheiden. Notiert wird dies durch  ähnelt.
    2127         /// </summary>
    2128         public static string Tutorial2CharacteristicSlide1Content1Run3 {
    2129             get {
    2130                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content1Run3", resourceCulture);
    2131             }
    2132         }
    2133        
    2134         /// <summary>
    2135         ///   Sucht eine lokalisierte Zeichenfolge, die Charakteristiken können miteinander kombiniert und so über mehrere Runden verbunden werden. Vorraussetzung dafür ist, dass die Ausgangsdifferenz der vorgänger Charakteristik denselben Wert wie die Eingangsdifferenz der nachfolgenden Charakteristik aufweist. Unter der Annahme, dass Charakteristiken unabhängig voneinander sind, können die Wahrscheinlichkeiten multipliziert werden. Auf diese Weise kann ein Weg von Differenzen durch die Chiffre gesucht werden. ähnelt.
    2136         /// </summary>
    2137         public static string Tutorial2CharacteristicSlide1Content2 {
    2138             get {
    2139                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content2", resourceCulture);
    2140             }
    2141         }
    2142        
    2143         /// <summary>
    2144         ///   Sucht eine lokalisierte Zeichenfolge, die Wir bezeichnen ein solches Paar  ähnelt.
    2145         /// </summary>
    2146         public static string Tutorial2CharacteristicSlide1Content2Run1 {
    2147             get {
    2148                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content2Run1", resourceCulture);
    2149             }
    2150         }
    2151        
    2152         /// <summary>
    2153         ///   Sucht eine lokalisierte Zeichenfolge, die  als differenzielle charakteristik unter der Operation der SBox. Wie zuvor gesehen, hat eine differenzielle Charakteristik eine feste Wahrscheinlichkeit. ähnelt.
    2154         /// </summary>
    2155         public static string Tutorial2CharacteristicSlide1Content2Run2 {
    2156             get {
    2157                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content2Run2", resourceCulture);
    2158             }
    2159         }
    2160        
    2161         /// <summary>
    2162         ///   Sucht eine lokalisierte Zeichenfolge, die Ziel bei der Suche ist es, einen Weg zu finden, der eine möglichst hohe Wahrscheinlichkeit aufweist. ähnelt.
    2163         /// </summary>
    2164         public static string Tutorial2CharacteristicSlide1Content3 {
    2165             get {
    2166                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Content3", resourceCulture);
    2167             }
    2168         }
    2169        
    2170         /// <summary>
    2171         ///   Sucht eine lokalisierte Zeichenfolge, die Characteristics ähnelt.
    2172         /// </summary>
    2173         public static string Tutorial2CharacteristicSlide1Header {
    2174             get {
    2175                 return ResourceManager.GetString("Tutorial2CharacteristicSlide1Header", resourceCulture);
    2176             }
    2177         }
    2178        
    2179         /// <summary>
    2180         ///   Sucht eine lokalisierte Zeichenfolge, die Die differenziellen Charakteristiken einzelner Runde sollen jetzt zu einem Weg von Differenzen durch die gesamte Chiffre kombiniert werden. Die Suche nach Pfaden mit hoher Wahrscheinlichkeit ist ein aufwändiges und zeitaufwändiges Problem bei Chiffren mit vielen Verschlüsselungsrunden und langen Blöcken. ähnelt.
    2181         /// </summary>
    2182         public static string Tutorial2CharacteristicSlide3Content1 {
    2183             get {
    2184                 return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content1", resourceCulture);
    2185             }
    2186         }
    2187        
    2188         /// <summary>
    2189         ///   Sucht eine lokalisierte Zeichenfolge, die Die PfadFinder-Komponente verfügt über verschiedene Suchoptionen zur Bestimmung von solchen Pfaden. ähnelt.
    2190         /// </summary>
    2191         public static string Tutorial2CharacteristicSlide3Content2 {
    2192             get {
    2193                 return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content2", resourceCulture);
    2194             }
    2195         }
    2196        
    2197         /// <summary>
    2198         ///   Sucht eine lokalisierte Zeichenfolge, die Die zuvor eingeführte Notation wird verwendet, um differenzielle Charakteristiken einer Runde zu differenziellen Charakteristiken für n-Verschlüsselungsrunden (hier: 3) zu bezeichnen: ähnelt.
    2199         /// </summary>
    2200         public static string Tutorial2CharacteristicSlide3Content3 {
    2201             get {
    2202                 return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content3", resourceCulture);
    2203             }
    2204         }
    2205        
    2206         /// <summary>
    2207         ///   Sucht eine lokalisierte Zeichenfolge, die Im ersten 4-Tupel sind die Eingangsdifferenzen der SBoxen der ersten 4 SBoxen in der ersten Verschlüsselungsrunde angegeben. Im 2. 4-Tupel ist sowohl die Ausgangsdifferenz der ersten als auch die Eingangsdifferenz der zweiten Verschlüsselungsrunde notiert. Im 3. 4-Tupel ist die Ausgangsdifferenz der zweiten und die Eingangsdifferenz der letzten Verschlüsselungsrunde notiert. ähnelt.
    2208         /// </summary>
    2209         public static string Tutorial2CharacteristicSlide3Content4 {
    2210             get {
    2211                 return ResourceManager.GetString("Tutorial2CharacteristicSlide3Content4", resourceCulture);
    2212             }
    2213         }
    2214        
    2215         /// <summary>
    2216         ///   Sucht eine lokalisierte Zeichenfolge, die Characteristics ähnelt.
    2217         /// </summary>
    2218         public static string Tutorial2CharacteristicSlide3Header {
    2219             get {
    2220                 return ResourceManager.GetString("Tutorial2CharacteristicSlide3Header", resourceCulture);
    2221             }
    2222         }
    2223        
    2224         /// <summary>
    2225         ///   Sucht eine lokalisierte Zeichenfolge, die 5. Differentials ähnelt.
    2226         /// </summary>
    2227         public static string Tutorial2DifferentialHeader {
    2228             get {
    2229                 return ResourceManager.GetString("Tutorial2DifferentialHeader", resourceCulture);
    2230             }
    2231         }
    2232        
    2233         /// <summary>
    2234         ///   Sucht eine lokalisierte Zeichenfolge, die Bei der Suche nach Charakteristiken über n Runden kann es vorkommen, dass dass verschiedene Charakteristiken gefunden werden, die die selbe Eingangsdifferenz der ersten und Ausgangsdifferenz der letzten Verschlüsselungsrunde haben. Die Charakteristiken haben also die Form ähnelt.
    2235         /// </summary>
    2236         public static string Tutorial2DifferentialSlide1Content1 {
    2237             get {
    2238                 return ResourceManager.GetString("Tutorial2DifferentialSlide1Content1", resourceCulture);
    2239             }
    2240         }
    2241        
    2242         /// <summary>
    2243         ///   Sucht eine lokalisierte Zeichenfolge, die Entscheidend bei der Verwendung von Charakteristiken für die differenzielle Kryptoanalyse sind Eingangs- und Ausgangswert der Differenz. Findet man mehrere Charakteristiken mit selben Eingangs- und Ausgangswert, können die Wahrscheinlichkeiten addiert werden. Eine Struktur, die aus mehreren Charakteristiken besteht, wird Differenzial genannt. ähnelt.
    2244         /// </summary>
    2245         public static string Tutorial2DifferentialSlide1Content2 {
    2246             get {
    2247                 return ResourceManager.GetString("Tutorial2DifferentialSlide1Content2", resourceCulture);
    2248             }
    2249         }
    2250        
    2251         /// <summary>
    2252         ///   Sucht eine lokalisierte Zeichenfolge, die Ziel bei der Analyse einer Chiffre ist es also, das Differenzial mit der höchsten Wahrscheinlichkeit zu finden. ähnelt.
    2253         /// </summary>
    2254         public static string Tutorial2DifferentialSlide1Content3 {
    2255             get {
    2256                 return ResourceManager.GetString("Tutorial2DifferentialSlide1Content3", resourceCulture);
    2257             }
    2258         }
    2259        
    2260         /// <summary>
    2261         ///   Sucht eine lokalisierte Zeichenfolge, die Differentials ähnelt.
    2262         /// </summary>
    2263         public static string Tutorial2DifferentialSlide1Header {
    2264             get {
    2265                 return ResourceManager.GetString("Tutorial2DifferentialSlide1Header", resourceCulture);
    2266             }
    2267         }
    2268        
    2269         /// <summary>
    2270         ///   Sucht eine lokalisierte Zeichenfolge, die 1. Introduction ähnelt.
    2271         /// </summary>
    2272         public static string Tutorial2IntroductionHeader {
    2273             get {
    2274                 return ResourceManager.GetString("Tutorial2IntroductionHeader", resourceCulture);
    2275             }
    2276         }
    2277        
    2278         /// <summary>
    2279         ///   Sucht eine lokalisierte Zeichenfolge, die In tutorial 1 the idea of differential cryptanalysis was introduced and demonstrated with a cipher consisting of one encryption round with two round keys. ähnelt.
    2280         /// </summary>
    2281         public static string Tutorial2IntroductionSlide1Content1 {
    2282             get {
    2283                 return ResourceManager.GetString("Tutorial2IntroductionSlide1Content1", resourceCulture);
    2284             }
    2285         }
    2286        
    2287         /// <summary>
    2288         ///   Sucht eine lokalisierte Zeichenfolge, die In this tutorial the idea is deepened and shown at a cipher with three encryption rounds with four round keys. ähnelt.
    2289         /// </summary>
    2290         public static string Tutorial2IntroductionSlide1Content2 {
    2291             get {
    2292                 return ResourceManager.GetString("Tutorial2IntroductionSlide1Content2", resourceCulture);
    2293             }
    2294         }
    2295        
    2296         /// <summary>
    2297         ///   Sucht eine lokalisierte Zeichenfolge, die Um eine Chiffre mit mehreren Verschlüsselgsrunden und Rundenschlüsseln mittels differenzieller Kryptoanalyse anzugreifen, muss diese genauer untersucht werden. Von Interesse sind die einzelnen Bestandteile der Verschlüsselungsrunden und wie diese sich verhalten. ähnelt.
    2298         /// </summary>
    2299         public static string Tutorial2IntroductionSlide1Content3 {
    2300             get {
    2301                 return ResourceManager.GetString("Tutorial2IntroductionSlide1Content3", resourceCulture);
    2302             }
    2303         }
    2304        
    2305         /// <summary>
    2306         ///   Sucht eine lokalisierte Zeichenfolge, die Aufgrund der mehrfachen Verschlüsselungsrunden kann diese Chiffre nicht wie Chiffre 1 angegriffen werden. Für Chiffre 2 wird ein Ansatz benötigt, der die Änderungen von differenzen über mehrere Verschlüsselungsrunden mit einer gewissen Wahrscheinlichkeit vorraussagt. ähnelt.
    2307         /// </summary>
    2308         public static string Tutorial2IntroductionSlide1Content4 {
    2309             get {
    2310                 return ResourceManager.GetString("Tutorial2IntroductionSlide1Content4", resourceCulture);
    2311             }
    2312         }
    2313        
    2314         /// <summary>
    2315         ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
    2316         /// </summary>
    2317         public static string Tutorial2IntroductionSlide1Header {
    2318             get {
    2319                 return ResourceManager.GetString("Tutorial2IntroductionSlide1Header", resourceCulture);
    2320             }
    2321         }
    2322        
    2323         /// <summary>
    2324         ///   Sucht eine lokalisierte Zeichenfolge, die 6. Recover key information ähnelt.
    2325         /// </summary>
    2326         public static string Tutorial2RecoverKeyInformationHeader {
    2327             get {
    2328                 return ResourceManager.GetString("Tutorial2RecoverKeyInformationHeader", resourceCulture);
    2329             }
    2330         }
    2331        
    2332         /// <summary>
    2333         ///   Sucht eine lokalisierte Zeichenfolge, die Sobald ein Differenzial mit hoher Wahrscheinlichkeit gefunden wurde, kann damit begonnen werden, Schlüsselbits wiederherzustellen. Dazu werden die SBoxen betrachtet, an denen die erwartete Differenz von 0 verschieden ist. ähnelt.
    2334         /// </summary>
    2335         public static string Tutorial2RecoverKeyInformationSlide1Content1 {
    2336             get {
    2337                 return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Content1", resourceCulture);
    2338             }
    2339         }
    2340        
    2341         /// <summary>
    2342         ///   Sucht eine lokalisierte Zeichenfolge, die Für jeden möglichen Schlüsselkandidat wird ein Zähler erzeugt. Der Kryptoanalyst generiert eine Anzahl von Nachrichten, die die Eingabedifferenz erfüllen. Diese werden verschlüsselt und mit dem Schlüsselkandidat partiell entschlüsselt. Erfüllt die Differenz der partiell entschlüsselten Nachrichten die erwartete Differenz, wird der Zähler um 1 erhöht. Diesen Prozess wiederholt man mit allen generierten Nachrichtenpaaren. ähnelt.
    2343         /// </summary>
    2344         public static string Tutorial2RecoverKeyInformationSlide1Content2 {
    2345             get {
    2346                 return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Content2", resourceCulture);
    2347             }
    2348         }
    2349        
    2350         /// <summary>
    2351         ///   Sucht eine lokalisierte Zeichenfolge, die Der Schlüsselkandidat mit den meisten Treffern, sollte den höchsten Zähler haben. Dieser sollte sehr nah am Erwartungswert des Differenzial liegen. ähnelt.
    2352         /// </summary>
    2353         public static string Tutorial2RecoverKeyInformationSlide1Content3 {
    2354             get {
    2355                 return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Content3", resourceCulture);
    2356             }
    2357         }
    2358        
    2359         /// <summary>
    2360         ///   Sucht eine lokalisierte Zeichenfolge, die Recover key information ähnelt.
    2361         /// </summary>
    2362         public static string Tutorial2RecoverKeyInformationSlide1Header {
    2363             get {
    2364                 return ResourceManager.GetString("Tutorial2RecoverKeyInformationSlide1Header", resourceCulture);
    2365             }
    2366         }
    2367        
    2368         /// <summary>
    2369         ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial Differenzielle Kryptoanalyse symmetrischer Blockchiffren ähnelt.
    2370         /// </summary>
    2371         public static string Tutorial2TitleHeader {
    2372             get {
    2373                 return ResourceManager.GetString("Tutorial2TitleHeader", resourceCulture);
    2374             }
    2375         }
    2376        
    2377         /// <summary>
    2378         ///   Sucht eine lokalisierte Zeichenfolge, die You can now use the attack configuration generated in the PathFinder component in the KeyRecovery component to restore key bits. To do this, click the start button. ähnelt.
    2379         /// </summary>
    2380         public static string Tutorial2WaitingSlideContent1 {
    2381             get {
    2382                 return ResourceManager.GetString("Tutorial2WaitingSlideContent1", resourceCulture);
    2383             }
    2384         }
    2385        
    2386         /// <summary>
    2387         ///   Sucht eine lokalisierte Zeichenfolge, die Optionally, you can display the determined differential and its characteristics in the PathVisualiser component. ähnelt.
    2388         /// </summary>
    2389         public static string Tutorial2WaitingSlideContent2 {
    2390             get {
    2391                 return ResourceManager.GetString("Tutorial2WaitingSlideContent2", resourceCulture);
    2392             }
    2393         }
    2394        
    2395         /// <summary>
    2396         ///   Sucht eine lokalisierte Zeichenfolge, die Summary of the analysis results: ähnelt.
    2397         /// </summary>
    2398         public static string Tutorial2WaitingSlideContent3Run1 {
    2399             get {
    2400                 return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run1", resourceCulture);
    2401             }
    2402         }
    2403        
    2404         /// <summary>
    2405         ///   Sucht eine lokalisierte Zeichenfolge, die Input difference:  ähnelt.
    2406         /// </summary>
    2407         public static string Tutorial2WaitingSlideContent3Run2 {
    2408             get {
    2409                 return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run2", resourceCulture);
    2410             }
    2411         }
    2412        
    2413         /// <summary>
    2414         ///   Sucht eine lokalisierte Zeichenfolge, die Expected difference:  ähnelt.
    2415         /// </summary>
    2416         public static string Tutorial2WaitingSlideContent3Run3 {
    2417             get {
    2418                 return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run3", resourceCulture);
    2419             }
    2420         }
    2421        
    2422         /// <summary>
    2423         ///   Sucht eine lokalisierte Zeichenfolge, die Probability:  ähnelt.
    2424         /// </summary>
    2425         public static string Tutorial2WaitingSlideContent3Run4 {
    2426             get {
    2427                 return ResourceManager.GetString("Tutorial2WaitingSlideContent3Run4", resourceCulture);
    2428             }
    2429         }
    2430        
    2431         /// <summary>
    2432         ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis is continued in the following components. ähnelt.
    2433         /// </summary>
    2434         public static string Tutorial2WaitingSlideHeader {
    2435             get {
    2436                 return ResourceManager.GetString("Tutorial2WaitingSlideHeader", resourceCulture);
    2437             }
    2438         }
    2439        
    2440         /// <summary>
    2441         ///   Sucht eine lokalisierte Zeichenfolge, die X. Differential cryptanalysis of cipher 3 ähnelt.
    2442         /// </summary>
    2443         public static string Tutorial3AttackHeader {
    2444             get {
    2445                 return ResourceManager.GetString("Tutorial3AttackHeader", resourceCulture);
    2446             }
    2447         }
    2448        
    2449         /// <summary>
    2450         ///   Sucht eine lokalisierte Zeichenfolge, die SBoxen aus Runde 2 auswählen, um Schlüsselbits von K ähnelt.
    2451         /// </summary>