Changeset 8142


Ignore:
Timestamp:
Jun 1, 2019, 9:00:38 PM (3 years ago)
Author:
Christian Bender
Message:

DCAPathFinder: Implementation of ui for general introduction and tutorial 1 for dca of cipher1

Location:
trunk
Files:
44 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginsExperimental/DCAPathFinder/DCAPathFinder.cs

    r8140 r8142  
    1717using System;
    1818using System.ComponentModel;
     19using System.Threading;
    1920using System.Windows.Controls;
     21using System.Windows.Threading;
    2022using Cryptool.PluginBase;
    2123using Cryptool.PluginBase.Miscellaneous;
     24using DCAPathFinder;
    2225using DCAPathFinder.UI;
    2326
     
    3235
    3336        private readonly DCAPathFinderSettings settings = new DCAPathFinderSettings();
    34         private readonly DCAPathFinderPres pres = new DCAPathFinderPres();
     37        private readonly DCAPathFinderPres _activePresentation = new DCAPathFinderPres();
    3538        private int _expectedDifferential;
    3639        private int _messageCount;
     
    3942        #endregion
    4043
     44        public DCAPathFinder()
     45        {
     46            settings.PropertyChanged += new PropertyChangedEventHandler(SettingChangedListener);
     47        }
     48
    4149        #region Data Properties
    4250
     
    100108        public UserControl Presentation
    101109        {
    102             get { return pres; }
     110            get { return _activePresentation; }
    103111        }
    104112
     
    108116        public void PreExecution()
    109117        {
     118            //dispatch action: inform ui that workspace is running
     119            _activePresentation.Dispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     120            {
     121                _activePresentation.WorkspaceRunning = true;
     122            }, null);
    110123        }
    111124
     
    129142        public void PostExecution()
    130143        {
     144            //dispatch action: inform ui that workspace is stopped
     145            _activePresentation.Dispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     146            {
     147                _activePresentation.WorkspaceRunning = false;
     148            }, null);
    131149        }
    132150
     
    155173        #endregion
    156174
     175        #region methods
     176
     177        /// <summary>
     178        /// Handles changes within the settings class
     179        /// </summary>
     180        /// <param name="sender"></param>
     181        /// <param name="e"></param>
     182        private void SettingChangedListener(object sender, PropertyChangedEventArgs e)
     183        {
     184            //Listen for changes of the current chosen algorithm
     185            if (e.PropertyName == "CurrentAlgorithm")
     186            {
     187                //Check specific algorithm and invoke the selection into the UI class
     188                if (settings.CurrentAlgorithm == Algorithms.Cipher1)
     189                {
     190                    //dispatch action: set active tutorial number
     191                    _activePresentation.Dispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     192                    {
     193                        _activePresentation.TutorialNumber = 1;
     194                    }, null);
     195                }
     196                else if (settings.CurrentAlgorithm == Algorithms.Cipher2)
     197                {
     198                    //dispatch action: set active tutorial number
     199                    _activePresentation.Dispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     200                    {
     201                        _activePresentation.TutorialNumber = 2;
     202                    }, null);
     203                }
     204                else if (settings.CurrentAlgorithm == Algorithms.Cipher3)
     205                {
     206                    //dispatch action: set active tutorial number
     207                    _activePresentation.Dispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     208                    {
     209                        _activePresentation.TutorialNumber = 3;
     210                    }, null);
     211                }
     212                else if (settings.CurrentAlgorithm == Algorithms.Cipher4)
     213                {
     214                    //dispatch action: set active tutorial number
     215                    _activePresentation.Dispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
     216                    {
     217                        _activePresentation.TutorialNumber = 4;
     218                    }, null);
     219                }
     220            }
     221        }
     222
     223        #endregion
     224
    157225        #region Event Handling
    158226
  • trunk/CrypPluginsExperimental/DCAPathFinder/DCAPathFinder.csproj

    r8140 r8142  
    7676      <DependentUpon>Resources.resx</DependentUpon>
    7777    </Compile>
     78    <Compile Include="UI\Controls\16BitKeyRound.xaml.cs">
     79      <DependentUpon>16BitKeyRound.xaml</DependentUpon>
     80    </Compile>
     81    <Compile Include="UI\Controls\16BitPermutation.xaml.cs">
     82      <DependentUpon>16BitPermutation.xaml</DependentUpon>
     83    </Compile>
     84    <Compile Include="UI\Controls\4BitKeyRound.xaml.cs">
     85      <DependentUpon>4BitKeyRound.xaml</DependentUpon>
     86    </Compile>
     87    <Compile Include="UI\Controls\4BitSBox.xaml.cs">
     88      <DependentUpon>4BitSBox.xaml</DependentUpon>
     89    </Compile>
    7890    <Compile Include="UI\DCAPathFinderPres.xaml.cs">
    7991      <DependentUpon>DCAPathFinderPres.xaml</DependentUpon>
     
    8597      <DependentUpon>StartMask.xaml</DependentUpon>
    8698    </Compile>
     99    <Compile Include="UI\Tutorial1\DifferentialCryptanalysisHeader.xaml.cs">
     100      <DependentUpon>DifferentialCryptanalysisHeader.xaml</DependentUpon>
     101    </Compile>
     102    <Compile Include="UI\Tutorial1\DifferentialCryptanalysisSlide1.xaml.cs">
     103      <DependentUpon>DifferentialCryptanalysisSlide1.xaml</DependentUpon>
     104    </Compile>
     105    <Compile Include="UI\Tutorial1\DifferentialCryptanalysisSlide2.xaml.cs">
     106      <DependentUpon>DifferentialCryptanalysisSlide2.xaml</DependentUpon>
     107    </Compile>
     108    <Compile Include="UI\Tutorial1\DifferentialCryptanalysisSlide3.xaml.cs">
     109      <DependentUpon>DifferentialCryptanalysisSlide3.xaml</DependentUpon>
     110    </Compile>
     111    <Compile Include="UI\Tutorial1\IntroductionHeader.xaml.cs">
     112      <DependentUpon>IntroductionHeader.xaml</DependentUpon>
     113    </Compile>
     114    <Compile Include="UI\Tutorial1\IntroductionSlide1.xaml.cs">
     115      <DependentUpon>IntroductionSlide1.xaml</DependentUpon>
     116    </Compile>
     117    <Compile Include="UI\Tutorial1\IntroductionSlide2.xaml.cs">
     118      <DependentUpon>IntroductionSlide2.xaml</DependentUpon>
     119    </Compile>
     120    <Compile Include="UI\Tutorial1\IntroductionSlide3.xaml.cs">
     121      <DependentUpon>IntroductionSlide3.xaml</DependentUpon>
     122    </Compile>
     123    <Compile Include="UI\Tutorial1\Title.xaml.cs">
     124      <DependentUpon>Title.xaml</DependentUpon>
     125    </Compile>
     126    <Compile Include="UI\Tutorial1\XorTableMapping.cs" />
    87127    <Compile Include="UI\TutorialDescriptions.xaml.cs">
    88128      <DependentUpon>TutorialDescriptions.xaml</DependentUpon>
     
    127167  </ItemGroup>
    128168  <ItemGroup>
     169    <Page Include="UI\Controls\16BitKeyRound.xaml">
     170      <Generator>MSBuild:Compile</Generator>
     171      <SubType>Designer</SubType>
     172    </Page>
     173    <Page Include="UI\Controls\16BitPermutation.xaml">
     174      <Generator>MSBuild:Compile</Generator>
     175      <SubType>Designer</SubType>
     176    </Page>
     177    <Page Include="UI\Controls\4BitKeyRound.xaml">
     178      <Generator>MSBuild:Compile</Generator>
     179      <SubType>Designer</SubType>
     180    </Page>
     181    <Page Include="UI\Controls\4BitSBox.xaml">
     182      <Generator>MSBuild:Compile</Generator>
     183      <SubType>Designer</SubType>
     184    </Page>
    129185    <Page Include="UI\DCAPathFinderPres.xaml">
    130186      <SubType>Designer</SubType>
     
    139195      <Generator>MSBuild:Compile</Generator>
    140196    </Page>
     197    <Page Include="UI\Tutorial1\DifferentialCryptanalysisHeader.xaml">
     198      <SubType>Designer</SubType>
     199      <Generator>MSBuild:Compile</Generator>
     200    </Page>
     201    <Page Include="UI\Tutorial1\DifferentialCryptanalysisSlide1.xaml">
     202      <SubType>Designer</SubType>
     203      <Generator>MSBuild:Compile</Generator>
     204    </Page>
     205    <Page Include="UI\Tutorial1\DifferentialCryptanalysisSlide2.xaml">
     206      <SubType>Designer</SubType>
     207      <Generator>MSBuild:Compile</Generator>
     208    </Page>
     209    <Page Include="UI\Tutorial1\DifferentialCryptanalysisSlide3.xaml">
     210      <SubType>Designer</SubType>
     211      <Generator>MSBuild:Compile</Generator>
     212    </Page>
     213    <Page Include="UI\Tutorial1\IntroductionHeader.xaml">
     214      <SubType>Designer</SubType>
     215      <Generator>MSBuild:Compile</Generator>
     216    </Page>
     217    <Page Include="UI\Tutorial1\IntroductionSlide1.xaml">
     218      <SubType>Designer</SubType>
     219      <Generator>MSBuild:Compile</Generator>
     220    </Page>
     221    <Page Include="UI\Tutorial1\IntroductionSlide2.xaml">
     222      <SubType>Designer</SubType>
     223      <Generator>MSBuild:Compile</Generator>
     224    </Page>
     225    <Page Include="UI\Tutorial1\IntroductionSlide3.xaml">
     226      <SubType>Designer</SubType>
     227      <Generator>MSBuild:Compile</Generator>
     228    </Page>
     229    <Page Include="UI\Tutorial1\Title.xaml">
     230      <SubType>Designer</SubType>
     231      <Generator>MSBuild:Compile</Generator>
     232    </Page>
    141233    <Page Include="UI\TutorialDescriptions.xaml">
    142234      <SubType>Designer</SubType>
     
    144236    </Page>
    145237  </ItemGroup>
    146   <ItemGroup>
    147     <Folder Include="UI\Controls\" />
    148   </ItemGroup>
     238  <ItemGroup />
    149239  <ItemGroup>
    150240    <Resource Include="Images\next-button.png" />
    151241    <Resource Include="Images\prev-button.png" />
     242  </ItemGroup>
     243  <ItemGroup>
     244    <Resource Include="Images\mXORk.png" />
     245    <Resource Include="Images\mXORkXORk.png" />
     246  </ItemGroup>
     247  <ItemGroup>
     248    <Resource Include="Images\m1XORkm2XORk.png" />
     249  </ItemGroup>
     250  <ItemGroup>
     251    <Resource Include="Images\c1XORc2.png" />
     252  </ItemGroup>
     253  <ItemGroup>
     254    <Resource Include="Images\mXORk0.png" />
     255  </ItemGroup>
     256  <ItemGroup>
     257    <Resource Include="Images\StepSBOX.png" />
     258  </ItemGroup>
     259  <ItemGroup>
     260    <Resource Include="Images\vXORk1.png" />
    152261  </ItemGroup>
    153262  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPluginsExperimental/DCAPathFinder/Properties/Resources.Designer.cs

    r8141 r8142  
    197197       
    198198        /// <summary>
     199        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
     200        /// </summary>
     201        internal static string DifferentialCryptanalysisHeader {
     202            get {
     203                return ResourceManager.GetString("DifferentialCryptanalysisHeader", resourceCulture);
     204            }
     205        }
     206       
     207        /// <summary>
     208        ///   Sucht eine lokalisierte Zeichenfolge, die 2. differential cryptanalysis of cipher 1 ähnelt.
     209        /// </summary>
     210        internal static string DifferentialCryptanalysisHeader1 {
     211            get {
     212                return ResourceManager.GetString("DifferentialCryptanalysisHeader1", resourceCulture);
     213            }
     214        }
     215       
     216        /// <summary>
     217        ///   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 statement is described by the Kerckhoffs&apos; principle. ähnelt.
     218        /// </summary>
     219        internal static string DifferentialCryptanalysisSlide1Content1 {
     220            get {
     221                return ResourceManager.GetString("DifferentialCryptanalysisSlide1Content1", resourceCulture);
     222            }
     223        }
     224       
     225        /// <summary>
     226        ///   Sucht eine lokalisierte Zeichenfolge, die Chiffre 1 consists of key addition and substitution. The structure can be considered in the ToyChiffre component. We now try to restore the two unknown round keys k0 and k1. First we look at the individual steps of the encryption. First a key addition is performed with k0. We get: ähnelt.
     227        /// </summary>
     228        internal static string DifferentialCryptanalysisSlide1Content2 {
     229            get {
     230                return ResourceManager.GetString("DifferentialCryptanalysisSlide1Content2", resourceCulture);
     231            }
     232        }
     233       
     234        /// <summary>
     235        ///   Sucht eine lokalisierte Zeichenfolge, die Subsequently, a substitution by the SBoxes takes place: ähnelt.
     236        /// </summary>
     237        internal static string DifferentialCryptanalysisSlide1Content3 {
     238            get {
     239                return ResourceManager.GetString("DifferentialCryptanalysisSlide1Content3", resourceCulture);
     240            }
     241        }
     242       
     243        /// <summary>
     244        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
     245        /// </summary>
     246        internal static string DifferentialCryptanalysisSlide1Header {
     247            get {
     248                return ResourceManager.GetString("DifferentialCryptanalysisSlide1Header", resourceCulture);
     249            }
     250        }
     251       
     252        /// <summary>
     253        ///   Sucht eine lokalisierte Zeichenfolge, die Finally, a key addition with k1 takes place again: ähnelt.
     254        /// </summary>
     255        internal static string DifferentialCryptanalysisSlide2Content1 {
     256            get {
     257                return ResourceManager.GetString("DifferentialCryptanalysisSlide2Content1", resourceCulture);
     258            }
     259        }
     260       
     261        /// <summary>
     262        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
     263        /// </summary>
     264        internal static string DifferentialCryptanalysisSlide2Header {
     265            get {
     266                return ResourceManager.GetString("DifferentialCryptanalysisSlide2Header", resourceCulture);
     267            }
     268        }
     269       
     270        /// <summary>
     271        ///   Sucht eine lokalisierte Zeichenfolge, die The following figure summarizes the encryption process as outlined above: ähnelt.
     272        /// </summary>
     273        internal static string DifferentialCryptanalysisSlide3Content1 {
     274            get {
     275                return ResourceManager.GetString("DifferentialCryptanalysisSlide3Content1", resourceCulture);
     276            }
     277        }
     278       
     279        /// <summary>
     280        ///   Sucht eine lokalisierte Zeichenfolge, die Differential cryptanalysis of cipher 1 ähnelt.
     281        /// </summary>
     282        internal static string DifferentialCryptanalysisSlide3Header {
     283            get {
     284                return ResourceManager.GetString("DifferentialCryptanalysisSlide3Header", resourceCulture);
     285            }
     286        }
     287       
     288        /// <summary>
    199289        ///   Sucht eine lokalisierte Zeichenfolge, die Expected difference ähnelt.
    200290        /// </summary>
     
    215305       
    216306        /// <summary>
     307        ///   Sucht eine lokalisierte Zeichenfolge, die 1. IntroductionHeader ähnelt.
     308        /// </summary>
     309        internal static string IntroductionHeader {
     310            get {
     311                return ResourceManager.GetString("IntroductionHeader", resourceCulture);
     312            }
     313        }
     314       
     315        /// <summary>
     316        ///   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.
     317        /// </summary>
     318        internal static string IntroductionSlide1Content1 {
     319            get {
     320                return ResourceManager.GetString("IntroductionSlide1Content1", resourceCulture);
     321            }
     322        }
     323       
     324        /// <summary>
     325        ///   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.
     326        /// </summary>
     327        internal static string IntroductionSlide1Content2 {
     328            get {
     329                return ResourceManager.GetString("IntroductionSlide1Content2", resourceCulture);
     330            }
     331        }
     332       
     333        /// <summary>
     334        ///   Sucht eine lokalisierte Zeichenfolge, die Inputbit A ähnelt.
     335        /// </summary>
     336        internal static string IntroductionSlide1DataColHeader1 {
     337            get {
     338                return ResourceManager.GetString("IntroductionSlide1DataColHeader1", resourceCulture);
     339            }
     340        }
     341       
     342        /// <summary>
     343        ///   Sucht eine lokalisierte Zeichenfolge, die Inputbit B ähnelt.
     344        /// </summary>
     345        internal static string IntroductionSlide1DataColHeader2 {
     346            get {
     347                return ResourceManager.GetString("IntroductionSlide1DataColHeader2", resourceCulture);
     348            }
     349        }
     350       
     351        /// <summary>
     352        ///   Sucht eine lokalisierte Zeichenfolge, die Resultbit ähnelt.
     353        /// </summary>
     354        internal static string IntroductionSlide1DataColHeader3 {
     355            get {
     356                return ResourceManager.GetString("IntroductionSlide1DataColHeader3", resourceCulture);
     357            }
     358        }
     359       
     360        /// <summary>
     361        ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
     362        /// </summary>
     363        internal static string IntroductionSlide1Header {
     364            get {
     365                return ResourceManager.GetString("IntroductionSlide1Header", resourceCulture);
     366            }
     367        }
     368       
     369        /// <summary>
     370        ///   Sucht eine lokalisierte Zeichenfolge, die If the XOR operation is performed with a message m and key k, the ciphertext is generated: ähnelt.
     371        /// </summary>
     372        internal static string IntroductionSlide2Content1 {
     373            get {
     374                return ResourceManager.GetString("IntroductionSlide2Content1", resourceCulture);
     375            }
     376        }
     377       
     378        /// <summary>
     379        ///   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.
     380        /// </summary>
     381        internal static string IntroductionSlide2Content2 {
     382            get {
     383                return ResourceManager.GetString("IntroductionSlide2Content2", resourceCulture);
     384            }
     385        }
     386       
     387        /// <summary>
     388        ///   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.
     389        /// </summary>
     390        internal static string IntroductionSlide2Content3 {
     391            get {
     392                return ResourceManager.GetString("IntroductionSlide2Content3", resourceCulture);
     393            }
     394        }
     395       
     396        /// <summary>
     397        ///   Sucht eine lokalisierte Zeichenfolge, die In reality, ciphers are more extensive, more complicated and do not consist exclusively of key addition. Differential cryptanalysis is a so-called &quot;chosen plaintext attack&quot;, which means that the cryptanalyst can select messages and encrypt them. ähnelt.
     398        /// </summary>
     399        internal static string IntroductionSlide2Content4 {
     400            get {
     401                return ResourceManager.GetString("IntroductionSlide2Content4", resourceCulture);
     402            }
     403        }
     404       
     405        /// <summary>
     406        ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
     407        /// </summary>
     408        internal static string IntroductionSlide2Header {
     409            get {
     410                return ResourceManager.GetString("IntroductionSlide2Header", resourceCulture);
     411            }
     412        }
     413       
     414        /// <summary>
     415        ///   Sucht eine lokalisierte Zeichenfolge, die We can now use the idea of using the key twice. We are looking at two messages. Then the following can be calculated: ähnelt.
     416        /// </summary>
     417        internal static string IntroductionSlide3Content1 {
     418            get {
     419                return ResourceManager.GetString("IntroductionSlide3Content1", resourceCulture);
     420            }
     421        }
     422       
     423        /// <summary>
     424        ///   Sucht eine lokalisierte Zeichenfolge, die It is valid: ähnelt.
     425        /// </summary>
     426        internal static string IntroductionSlide3Content2 {
     427            get {
     428                return ResourceManager.GetString("IntroductionSlide3Content2", resourceCulture);
     429            }
     430        }
     431       
     432        /// <summary>
     433        ///   Sucht eine lokalisierte Zeichenfolge, die In words, we get the difference of the plain texts by calculating the difference of the key texts. ähnelt.
     434        /// </summary>
     435        internal static string IntroductionSlide3Content3 {
     436            get {
     437                return ResourceManager.GetString("IntroductionSlide3Content3", resourceCulture);
     438            }
     439        }
     440       
     441        /// <summary>
     442        ///   Sucht eine lokalisierte Zeichenfolge, die Introduction ähnelt.
     443        /// </summary>
     444        internal static string IntroductionSlide3Header {
     445            get {
     446                return ResourceManager.GetString("IntroductionSlide3Header", resourceCulture);
     447            }
     448        }
     449       
     450        /// <summary>
    217451        ///   Sucht eine lokalisierte Zeichenfolge, die Count of messages ähnelt.
    218452        /// </summary>
     
    269503       
    270504        /// <summary>
     505        ///   Sucht eine lokalisierte Zeichenfolge, die (This introduction can be skipped by starting the workspace) ähnelt.
     506        /// </summary>
     507        internal static string OverviewContent5 {
     508            get {
     509                return ResourceManager.GetString("OverviewContent5", resourceCulture);
     510            }
     511        }
     512       
     513        /// <summary>
    271514        ///   Sucht eine lokalisierte Zeichenfolge, die Differential Cryptanalysis Tutorial ähnelt.
    272515        /// </summary>
     
    310553            get {
    311554                return ResourceManager.GetString("PluginTooltip", resourceCulture);
     555            }
     556        }
     557       
     558        /// <summary>
     559        ///   Sucht eine lokalisierte Zeichenfolge, die The tutorial starts when you start the workspace. ähnelt.
     560        /// </summary>
     561        internal static string StartMaskContent1 {
     562            get {
     563                return ResourceManager.GetString("StartMaskContent1", resourceCulture);
     564            }
     565        }
     566       
     567        /// <summary>
     568        ///   Sucht eine lokalisierte Zeichenfolge, die You have currently selected Tutorial {0}. ähnelt.
     569        /// </summary>
     570        internal static string StartMaskContent2 {
     571            get {
     572                return ResourceManager.GetString("StartMaskContent2", resourceCulture);
     573            }
     574        }
     575       
     576        /// <summary>
     577        ///   Sucht eine lokalisierte Zeichenfolge, die Ready for execution ähnelt.
     578        /// </summary>
     579        internal static string StartMaskHeader {
     580            get {
     581                return ResourceManager.GetString("StartMaskHeader", resourceCulture);
     582            }
     583        }
     584       
     585        /// <summary>
     586        ///   Sucht eine lokalisierte Zeichenfolge, die Tutorial differential cryptanalysis of symmetric block ciphers ähnelt.
     587        /// </summary>
     588        internal static string TitleHeader {
     589            get {
     590                return ResourceManager.GetString("TitleHeader", resourceCulture);
    312591            }
    313592        }
  • trunk/CrypPluginsExperimental/DCAPathFinder/Properties/Resources.de.resx

    r8141 r8142  
    163163    <value>Tutorial 3</value>
    164164  </data>
     165  <data name="DifferentialCryptanalysisHeader" xml:space="preserve">
     166    <value>2. Differenzielle Kryptoanalyse von Chiffre 1</value>
     167  </data>
     168  <data name="DifferentialCryptanalysisSlide1Content1" xml:space="preserve">
     169    <value>An dieser Stelle wenden wir die Idee der differenziellen Kryptoanalyse auf Chiffre 1 an. Der Aufbau einer Chiffre ist in aller Regel öffentlich, sodass alle Bestandteile und deren Funktionsweise bekannt sind. Die Sicherheit einer Chiffre sollte niemals auf Geheimhaltung der Konstruktion basieren, sondern auf der Geheimhaltung des Schlüssels. Diese Aussage wird durch das Kerckhoffs’ Prinzip beschrieben.</value>
     170  </data>
     171  <data name="DifferentialCryptanalysisSlide1Content2" xml:space="preserve">
     172    <value>Chiffre 1 besteht aus Schlüsseladdition und Substitution. Der Aufbau kann in der ToyChiffre-Komponente als betrachtet werden. Wir versuchen nun die zwei unbekannten Rundenschlüssel k0 und k1 wiederherzustellen. Wir betrachten zunächst die einzelnen Schritte der Verschlüsselung. Zunächst wird eine Schlüsseladdition durchgeführt mit k0. Wir erhalten:</value>
     173  </data>
     174  <data name="DifferentialCryptanalysisSlide1Content3" xml:space="preserve">
     175    <value>Anschließend erfolgt eine Substitution durch die SBoxen:</value>
     176  </data>
     177  <data name="DifferentialCryptanalysisSlide1Header" xml:space="preserve">
     178    <value>Differenzielle Kryptoanalyse von Chiffre 1</value>
     179  </data>
     180  <data name="DifferentialCryptanalysisSlide2Content1" xml:space="preserve">
     181    <value>Als letztes erfolgt wieder eine Schlüsseladdition mit k1:</value>
     182  </data>
     183  <data name="DifferentialCryptanalysisSlide2Header" xml:space="preserve">
     184    <value>Differenzielle Kryptoanalyse von Chiffre 1</value>
     185  </data>
     186  <data name="DifferentialCryptanalysisSlide3Content1" xml:space="preserve">
     187    <value>Die folgende Abbildung fasst den Verschlüsselungsprozess, wie zuvor skizziert, zusammen:</value>
     188  </data>
     189  <data name="DifferentialCryptanalysisSlide3Header" xml:space="preserve">
     190    <value>Differenzielle Kryptoanalyse von Chiffre 1</value>
     191  </data>
    165192  <data name="ExpectedDifferential" xml:space="preserve">
    166193    <value>Erwartete Differenz</value>
     
    169196    <value>Diese Differenz beschreibt den Erwartungswert, der an der zuvor spezifizierten Stelle (Runde, SBox) mit hoher Wahrscheinlichkeit auftreten soll</value>
    170197  </data>
     198  <data name="IntroductionHeader" xml:space="preserve">
     199    <value>1. Einführung</value>
     200  </data>
     201  <data name="IntroductionSlide1Content1" xml:space="preserve">
     202    <value>In diesem Abschnitt betrachten wir die Basisidee der differenziellen Kryptoanalyse. Viele symmetrische rundenbasierte Blockchiffren bestehen aus drei grundlegenden Operationen: Schlüsseladdition, Substitution und Permutation. In diesem Abschnitt beschränken wir uns zunächst auf Schlüsseladdition und Substitution.</value>
     203  </data>
     204  <data name="IntroductionSlide1Content2" xml:space="preserve">
     205    <value>Bei der Schlüsseladdition verwenden sehr viele Chiffren die XOR-Operation (Exklusiv-Oder). Die XOR-Operation ist ein zweistelliger-Operator, der durch folgende Wertetabelle beschrieben werden kann:</value>
     206  </data>
     207  <data name="IntroductionSlide1DataColHeader1" xml:space="preserve">
     208    <value>Eingabebit A</value>
     209  </data>
     210  <data name="IntroductionSlide1DataColHeader2" xml:space="preserve">
     211    <value>Eingabebit B</value>
     212  </data>
     213  <data name="IntroductionSlide1DataColHeader3" xml:space="preserve">
     214    <value>Ergebnisbit</value>
     215  </data>
     216  <data name="IntroductionSlide1Header" xml:space="preserve">
     217    <value>Einführung</value>
     218  </data>
     219  <data name="IntroductionSlide2Content1" xml:space="preserve">
     220    <value>Wird die XOR-Operation mit einer Nachricht m und Schlüssel k durchgeführt, erhält man den Schlüsseltext:</value>
     221  </data>
     222  <data name="IntroductionSlide2Content2" xml:space="preserve">
     223    <value>Die Kernidee der differenziellen Kryptoanalyse ist es nun, dass der Schlüssel zweimal verwendet wird. Wir betrachten an dieser Stelle die Auswirkung:</value>
     224  </data>
     225  <data name="IntroductionSlide2Content3" xml:space="preserve">
     226    <value>Wir erhalten wieder die ursprüngliche Nachricht m. Die XOR-Operation wird häufig auch als Differenz-Operator bezeichnet. Dies werden wir in diesem Tutorial auch machen.</value>
     227  </data>
     228  <data name="IntroductionSlide2Content4" xml:space="preserve">
     229    <value>In der Realität sind Chiffren umfangreicher, komplizierter und bestehen nicht ausschließlich aus Schlüsseladdition. Die differenzielle Kryptoanalyse ist ein so genannter "Chosen Plaintext-Angriff", das bedeutet der Kryptoanalyst kann Nachrichten auswählen und diese verschlüsseln lassen.</value>
     230  </data>
     231  <data name="IntroductionSlide2Header" xml:space="preserve">
     232    <value>Einführung</value>
     233  </data>
     234  <data name="IntroductionSlide3Content1" xml:space="preserve">
     235    <value>Die Idee des zweimaligen Anwenden des Schlüssels können wir nun verwenden. Wir betrachten zwei Nachrichten. Dann kann folgendes berechnet werden:</value>
     236  </data>
     237  <data name="IntroductionSlide3Content2" xml:space="preserve">
     238    <value>Nun gilt:</value>
     239  </data>
     240  <data name="IntroductionSlide3Content3" xml:space="preserve">
     241    <value>In Worten, wir erhalten die Differenz der Klartexte durch Berechnung der Differenz der Schlüsseltexte.</value>
     242  </data>
     243  <data name="IntroductionSlide3Header" xml:space="preserve">
     244    <value>Einführung</value>
     245  </data>
    171246  <data name="MessageCount" xml:space="preserve">
    172247    <value>Nachrichtenanzahl</value>
     
    187262    <value>Viel Spaß beim Ausprobieren und Brechen der Chiffren!</value>
    188263  </data>
     264  <data name="OverviewContent5" xml:space="preserve">
     265    <value>(Diese Einführung kann durch Starten des Workspaces übersprungen werden)</value>
     266  </data>
    189267  <data name="OverviewHeader" xml:space="preserve">
    190268    <value>Tutorial zur differenziellen Kryptoanalyse</value>
     
    202280    <value>Die DCA PfadFinder-Komponente sucht in Abhängigkeit von durch den User spezifizierten Parametern nach Differenzialen in einer symmetrischen Blockchiffre.</value>
    203281  </data>
     282  <data name="StartMaskContent1" xml:space="preserve">
     283    <value>Durch Starten des Workspaces beginnt das Tutorial.</value>
     284  </data>
     285  <data name="StartMaskContent2" xml:space="preserve">
     286    <value>Sie haben Tutorial {0} zur Zeit ausgwählt.</value>
     287  </data>
     288  <data name="StartMaskHeader" xml:space="preserve">
     289    <value>Bereit zur Ausführung</value>
     290  </data>
     291  <data name="TitleHeader" xml:space="preserve">
     292    <value>Tutorial Differenzielle Kryptoanalyse symmetrischer Blockchiffren</value>
     293  </data>
    204294</root>
  • trunk/CrypPluginsExperimental/DCAPathFinder/Properties/Resources.resx

    r8141 r8142  
    163163    <value>Tutorial 3</value>
    164164  </data>
     165  <data name="DifferentialCryptanalysisHeader" xml:space="preserve">
     166    <value>Differential cryptanalysis of cipher 1</value>
     167  </data>
     168  <data name="DifferentialCryptanalysisHeader1" xml:space="preserve">
     169    <value>2. differential cryptanalysis of cipher 1</value>
     170  </data>
     171  <data name="DifferentialCryptanalysisSlide1Content1" xml:space="preserve">
     172    <value>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 statement is described by the Kerckhoffs' principle.</value>
     173  </data>
     174  <data name="DifferentialCryptanalysisSlide1Content2" xml:space="preserve">
     175    <value>Chiffre 1 consists of key addition and substitution. The structure can be considered in the ToyChiffre component. We now try to restore the two unknown round keys k0 and k1. First we look at the individual steps of the encryption. First a key addition is performed with k0. We get:</value>
     176  </data>
     177  <data name="DifferentialCryptanalysisSlide1Content3" xml:space="preserve">
     178    <value>Subsequently, a substitution by the SBoxes takes place:</value>
     179  </data>
     180  <data name="DifferentialCryptanalysisSlide1Header" xml:space="preserve">
     181    <value>Differential cryptanalysis of cipher 1</value>
     182  </data>
     183  <data name="DifferentialCryptanalysisSlide2Content1" xml:space="preserve">
     184    <value>Finally, a key addition with k1 takes place again:</value>
     185  </data>
     186  <data name="DifferentialCryptanalysisSlide2Header" xml:space="preserve">
     187    <value>Differential cryptanalysis of cipher 1</value>
     188  </data>
     189  <data name="DifferentialCryptanalysisSlide3Content1" xml:space="preserve">
     190    <value>The following figure summarizes the encryption process as outlined above:</value>
     191  </data>
     192  <data name="DifferentialCryptanalysisSlide3Header" xml:space="preserve">
     193    <value>Differential cryptanalysis of cipher 1</value>
     194  </data>
    165195  <data name="ExpectedDifferential" xml:space="preserve">
    166196    <value>Expected difference</value>
     
    169199    <value>This difference describes the expected value that should occur with a high probability at the previously specified position ( round, SBox).</value>
    170200  </data>
     201  <data name="IntroductionHeader" xml:space="preserve">
     202    <value>1. IntroductionHeader</value>
     203  </data>
     204  <data name="IntroductionSlide1Content1" xml:space="preserve">
     205    <value>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.</value>
     206  </data>
     207  <data name="IntroductionSlide1Content2" xml:space="preserve">
     208    <value>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:</value>
     209  </data>
     210  <data name="IntroductionSlide1DataColHeader1" xml:space="preserve">
     211    <value>Inputbit A</value>
     212  </data>
     213  <data name="IntroductionSlide1DataColHeader2" xml:space="preserve">
     214    <value>Inputbit B</value>
     215  </data>
     216  <data name="IntroductionSlide1DataColHeader3" xml:space="preserve">
     217    <value>Resultbit</value>
     218  </data>
     219  <data name="IntroductionSlide1Header" xml:space="preserve">
     220    <value>Introduction</value>
     221  </data>
     222  <data name="IntroductionSlide2Content1" xml:space="preserve">
     223    <value>If the XOR operation is performed with a message m and key k, the ciphertext is generated:</value>
     224  </data>
     225  <data name="IntroductionSlide2Content2" xml:space="preserve">
     226    <value>The core idea of differential cryptanalysis is now to use the key twice. Let's look at the impact at this point:</value>
     227  </data>
     228  <data name="IntroductionSlide2Content3" xml:space="preserve">
     229    <value>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.</value>
     230  </data>
     231  <data name="IntroductionSlide2Content4" xml:space="preserve">
     232    <value>In reality, ciphers are more extensive, more complicated and do not consist exclusively of key addition. Differential cryptanalysis is a so-called "chosen plaintext attack", which means that the cryptanalyst can select messages and encrypt them.</value>
     233  </data>
     234  <data name="IntroductionSlide2Header" xml:space="preserve">
     235    <value>Introduction</value>
     236  </data>
     237  <data name="IntroductionSlide3Content1" xml:space="preserve">
     238    <value>We can now use the idea of using the key twice. We are looking at two messages. Then the following can be calculated:</value>
     239  </data>
     240  <data name="IntroductionSlide3Content2" xml:space="preserve">
     241    <value>It is valid:</value>
     242  </data>
     243  <data name="IntroductionSlide3Content3" xml:space="preserve">
     244    <value>In words, we get the difference of the plain texts by calculating the difference of the key texts.</value>
     245  </data>
     246  <data name="IntroductionSlide3Header" xml:space="preserve">
     247    <value>Introduction</value>
     248  </data>
    171249  <data name="MessageCount" xml:space="preserve">
    172250    <value>Count of messages</value>
     
    187265    <value>Have fun trying out and breaking the ciphers!</value>
    188266  </data>
     267  <data name="OverviewContent5" xml:space="preserve">
     268    <value>(This introduction can be skipped by starting the workspace)</value>
     269  </data>
    189270  <data name="OverviewHeader" xml:space="preserve">
    190271    <value>Differential Cryptanalysis Tutorial</value>
     
    202283    <value>The DCA PathFinder component searches for differentials in a symmetric block cipher depending on parameters specified by the user.</value>
    203284  </data>
     285  <data name="StartMaskContent1" xml:space="preserve">
     286    <value>The tutorial starts when you start the workspace.</value>
     287  </data>
     288  <data name="StartMaskContent2" xml:space="preserve">
     289    <value>You have currently selected Tutorial {0}.</value>
     290  </data>
     291  <data name="StartMaskHeader" xml:space="preserve">
     292    <value>Ready for execution</value>
     293  </data>
     294  <data name="TitleHeader" xml:space="preserve">
     295    <value>Tutorial differential cryptanalysis of symmetric block ciphers</value>
     296  </data>
    204297</root>
  • trunk/CrypPluginsExperimental/DCAPathFinder/UI/DCAPathFinderPres.xaml

    r8140 r8142  
    2020        </Viewbox>
    2121        <!-- Footer of the slides -->
    22         <StackPanel Grid.Row="1" HorizontalAlignment="Center" Orientation="Horizontal">
    23             <Button Name="BtnPrevious" HorizontalAlignment="Center" Margin="5,0,5,0" Click="BtnPreviousClicked">
    24                 <Image Source="/DCAPathFinder;component/images/prev-button.png"/>
    25             </Button>
    26             <Button Name="BtnNext" HorizontalAlignment="Center" Margin="5,0,5,0" Click="BtnNextClicked">
    27                 <Image Source="/DCAPathFinder;component/images/next-button.png"/>
    28             </Button>
    29             <Button Name="BtnSkip" Content="{Loc BtnSkipChapter}" HorizontalAlignment="Center" Margin="5,0,5,0"></Button>
    30         </StackPanel>
     22        <Grid Grid.Row="1">
     23            <Grid.ColumnDefinitions>
     24                <ColumnDefinition Width="8*"></ColumnDefinition>
     25                <ColumnDefinition Width="2*"></ColumnDefinition>
     26            </Grid.ColumnDefinitions>
     27            <StackPanel Grid.Row="0" Grid.ColumnSpan="2" HorizontalAlignment="Center" Orientation="Horizontal">
     28                <Button Name="BtnPrevious" HorizontalAlignment="Center" Margin="5,0,5,0" Click="BtnPreviousClicked" IsEnabled="{Binding IsPreviousPossible, Mode=OneWay}">
     29                    <Image Source="/DCAPathFinder;component/images/prev-button.png"/>
     30                </Button>
     31                <Button Name="BtnNext" HorizontalAlignment="Center" Margin="5,0,5,0" Click="BtnNextClicked" IsEnabled="{Binding IsNextPossible, Mode=OneWay}">
     32                    <Image Source="/DCAPathFinder;component/images/next-button.png"/>
     33                </Button>
     34                <Button Name="BtnSkip" Content="{Loc BtnSkipChapter}" HorizontalAlignment="Center" Margin="5,0,5,0" IsEnabled="False"></Button>
     35            </StackPanel>
     36            <StackPanel Grid.Column="1" Width="30" HorizontalAlignment="Right" VerticalAlignment="Bottom">
     37                <Label FontFamily="Courier New" FontSize="8" Content="{Binding SlideCounter, Mode=OneWay}" Margin="0,0,0,-5"></Label>
     38            </StackPanel>
     39        </Grid>
     40       
    3141    </Grid>
    3242</UserControl>
  • trunk/CrypPluginsExperimental/DCAPathFinder/UI/DCAPathFinderPres.xaml.cs

    r8140 r8142  
    1 using System.Windows;
     1using System.ComponentModel;
     2using System.Runtime.CompilerServices;
     3using System.Windows;
    24using System.Windows.Controls;
     5using System.Windows.Data;
    36
    47namespace DCAPathFinder.UI
     
    811    /// </summary>
    912    [Cryptool.PluginBase.Attributes.Localization("DCAPathFinder.Properties.Resources")]
    10     public partial class DCAPathFinderPres : UserControl
     13    public partial class DCAPathFinderPres : UserControl, INotifyPropertyChanged
    1114    {
    1215        private int _stepCounter;
     16        private int _tutorialNumber;
     17        private int _currentTutorialLastSlideNumber;
     18        private string _selectedTutorial;
     19        private bool _isNextPossible;
     20        private bool _isPreviousPossible;
     21        private bool _workspaceRunning;
    1322
    1423        /// <summary>
     
    1827        {
    1928            _stepCounter = 0;
    20 
     29            _currentTutorialLastSlideNumber = 3;
     30            _workspaceRunning = false;
     31            _isNextPossible = true;
     32            _isPreviousPossible = false;
     33
     34            DataContext = this;
    2135            InitializeComponent();
    2236
     
    2943        private void SetupView()
    3044        {
    31             switch (_stepCounter)
    32             {
    33                 case 0:
     45            //introduction slides
     46            if (!WorkspaceRunning)
     47            {
     48                _currentTutorialLastSlideNumber = 3;
     49                switch (StepCounter)
    3450                {
    35                     ContentViewBox.Child = new Overview();
     51                    case 0:
     52                    {
     53                        //setup possible button actions
     54                        IsPreviousPossible = false;
     55                        IsNextPossible = true;
     56
     57                        //setup pres content
     58                        ContentViewBox.Child = new Overview();
     59                    }
     60                        break;
     61                    case 1:
     62                    {
     63                        //setup possible button actions
     64                        IsPreviousPossible = true;
     65                        IsNextPossible = true;
     66
     67                        //setup pres content
     68                        ContentViewBox.Child = new TutorialDescriptions();
     69                    }
     70                        break;
     71                    case 2:
     72                    {
     73                        //setup possible button actions
     74                        IsPreviousPossible = true;
     75                        IsNextPossible = false;
     76
     77                        //setup pres content
     78                        var startMask = new StartMask();
     79                        Binding myBinding = new Binding();
     80                        myBinding.Source = this;
     81                        myBinding.Path = new PropertyPath("SelectedTutorial");
     82                        myBinding.Mode = BindingMode.OneWay;
     83                        BindingOperations.SetBinding(startMask.TutorialTextBlock, TextBlock.TextProperty, myBinding);
     84                        ContentViewBox.Child = startMask;
     85                    }
     86                        break;
    3687                }
    37                     break;
    38                 case 1:
     88            }
     89            //tutorial slides
     90            else
     91            {
     92                //check the selected tutorial number
     93                switch (TutorialNumber)
    3994                {
    40                     ContentViewBox.Child = new TutorialDescriptions();
     95                    //this is tutorial number 1
     96                    case 1:
     97                    {
     98                        _currentTutorialLastSlideNumber = 10;
     99                        //check the current step
     100                        switch (StepCounter)
     101                        {
     102                            case 0:
     103                            {
     104                                //setup possible button actions
     105                                IsPreviousPossible = false;
     106                                IsNextPossible = true;
     107
     108                                //setup pres content
     109                                ContentViewBox.Child = new Tutorial1.Title();
     110                            }
     111                                break;
     112                            case 1:
     113                            {
     114                                //setup possible button actions
     115                                IsPreviousPossible = true;
     116                                IsNextPossible = true;
     117
     118                                //setup pres content
     119                                ContentViewBox.Child = new Tutorial1.IntroductionHeader();
     120                            }
     121                                break;
     122                            case 2:
     123                            {
     124                                //setup possible button actions
     125                                IsPreviousPossible = true;
     126                                IsNextPossible = true;
     127
     128                                //setup pres content
     129                                ContentViewBox.Child = new Tutorial1.IntroductionSlide1();
     130                            }
     131                                break;
     132                            case 3:
     133                            {
     134                                //setup possible button actions
     135                                IsPreviousPossible = true;
     136                                IsNextPossible = true;
     137
     138                                //setup pres content
     139                                ContentViewBox.Child = new Tutorial1.IntroductionSlide2();
     140                            }
     141                                break;
     142                            case 4:
     143                            {
     144                                //setup possible button actions
     145                                IsPreviousPossible = true;
     146                                IsNextPossible = true;
     147
     148                                //setup pres content
     149                                ContentViewBox.Child = new Tutorial1.IntroductionSlide3();
     150                            }
     151                                break;
     152                            case 5:
     153                            {
     154                                //setup possible button actions
     155                                IsPreviousPossible = true;
     156                                IsNextPossible = true;
     157
     158                                //setup pres content
     159                                ContentViewBox.Child = new Tutorial1.DifferentialCryptanalysisHeader();
     160                            }
     161                                break;
     162                            case 6:
     163                            {
     164                                //setup possible button actions
     165                                IsPreviousPossible = true;
     166                                IsNextPossible = true;
     167
     168                                //setup pres content
     169                                ContentViewBox.Child = new Tutorial1.DifferentialCryptanalysisSlide1();
     170                            }
     171                                break;
     172                            case 7:
     173                            {
     174                                //setup possible button actions
     175                                IsPreviousPossible = true;
     176                                IsNextPossible = true;
     177
     178                                //setup pres content
     179                                ContentViewBox.Child = new Tutorial1.DifferentialCryptanalysisSlide2();
     180                            }
     181                                break;
     182                            case 8:
     183                            {
     184                                //setup possible button actions
     185                                IsPreviousPossible = true;
     186                                IsNextPossible = true;
     187
     188                                //setup pres content
     189                                ContentViewBox.Child = new Tutorial1.DifferentialCryptanalysisSlide3();
     190                            }
     191                                break;                       
     192                        }
     193                    }
     194                        break;
    41195                }
    42                     break;
    43             }
    44         }
     196            }
     197        }
     198
     199        #region ButtonHandler
    45200
    46201        /// <summary>
     
    52207        {
    53208            //increment to go to the next step
    54             _stepCounter++;
     209            StepCounter++;
    55210            SetupView();
    56211        }
     
    64219        {
    65220            //decrement to go to the previous step
    66             _stepCounter--;
     221            StepCounter--;
    67222            SetupView();
    68223        }
     
    77232
    78233        }
     234
     235        #endregion
     236
     237        #region Properties
     238
     239        /// <summary>
     240        /// Property for indicating that the workspace is running
     241        /// </summary>
     242        public bool WorkspaceRunning
     243        {
     244            get { return _workspaceRunning; }
     245            set
     246            {
     247                _workspaceRunning = value;
     248                OnPropertyChanged();
     249
     250                StepCounter = 0;
     251                SetupView();
     252            }
     253        }
     254
     255        /// <summary>
     256        /// Property for button previous
     257        /// </summary>
     258        public bool IsPreviousPossible
     259        {
     260            get { return _isPreviousPossible; }
     261            set
     262            {
     263                _isPreviousPossible = value;
     264                OnPropertyChanged();
     265            }
     266        }
     267
     268        /// <summary>
     269        /// Property for button next
     270        /// </summary>
     271        public bool IsNextPossible
     272        {
     273            get { return _isNextPossible; }
     274            set
     275            {
     276                _isNextPossible = value;
     277                OnPropertyChanged();
     278            }
     279        }
     280
     281        /// <summary>
     282        /// Property for selected Tutorial
     283        /// </summary>
     284        public string SelectedTutorial
     285        {
     286            get { return _selectedTutorial; }
     287            set
     288            {
     289                _selectedTutorial = value;
     290                OnPropertyChanged();
     291            }
     292        }
     293
     294        /// <summary>
     295        /// Property for the tutorial number
     296        /// </summary>
     297        public int TutorialNumber
     298        {
     299            get { return _tutorialNumber; }
     300            set
     301            {
     302                _tutorialNumber = value;
     303                SelectedTutorial = Properties.Resources.StartMaskContent2.Replace("{0}", TutorialNumber.ToString());
     304                OnPropertyChanged();
     305            }
     306        }
     307
     308        /// <summary>
     309        /// Property for step counter
     310        /// </summary>
     311        public int StepCounter
     312        {
     313            get { return _stepCounter; }
     314            set
     315            {
     316                _stepCounter = value;
     317                OnPropertyChanged();
     318                OnPropertyChanged("SlideCounter");
     319            }
     320        }
     321
     322        /// <summary>
     323        /// Property for slide counter in the UI
     324        /// </summary>
     325        public string SlideCounter
     326        {
     327            get
     328            {
     329                return ((StepCounter + 1) + "/" + _currentTutorialLastSlideNumber);
     330            }
     331        }
     332
     333        #endregion
     334
     335        /// <summary>
     336        /// Event
     337        /// </summary>
     338        public event PropertyChangedEventHandler PropertyChanged;
     339
     340        /// <summary>
     341        /// Method to call if data changes
     342        /// </summary>
     343        /// <param name="propertyName"></param>
     344        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
     345        {
     346            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     347        }
    79348    }
    80349}
Note: See TracChangeset for help on using the changeset viewer.