Changeset 651


Ignore:
Timestamp:
Oct 5, 2009, 1:50:26 PM (12 years ago)
Author:
Sören Rinne
Message:
  • modified CubeAttack-Trivium672-Sample.cte
  • CLK now fires an output on mouse click in QuickWatchPresentation
  • LFSR and NLFSR QuickWatch can now be drawn before going into play mode
Location:
trunk
Files:
10 edited

Legend:

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

    r645 r651  
    1919
    2020using System.Windows;
     21// for setting image uri programmatically
     22using System.Windows.Media.Imaging;
    2123//using System.Windows.Data;
    2224//using System.IO;
     
    5052
    5153        cLKPresentation.CLKButtonImage.MouseLeftButtonUp += cLKButton_MouseLeftButtonUp;
    52         cLKPresentation.myTextBox.TextChanged += textchanged;
    53         //cLKPresentation.CLKButtonImage.MouseEnter += mousenter;
     54        cLKPresentation.CLKButtonImage.MouseLeftButtonDown += cLKButton_MouseLeftButtonUp;
    5455
    5556        // set picture according to settings value
     
    5960    }
    6061
    61     void mousenter(object sender, MouseEventArgs e)
    62     {
    63         GuiLogMessage("mouse event is coming", NotificationLevel.Info);
     62    void cLKButton_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
     63    {
    6464        OnPropertyChanged("Output");
    65     }
    66 
    67     void textchanged(object sender, TextChangedEventArgs e)
    68     {
    69         GuiLogMessage("text event is coming", NotificationLevel.Info);
    70         OnPropertyChanged("Output");
    71     }
    72 
    73     void cLKButton_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    74     {
    75         GuiLogMessage("mouse event is coming", NotificationLevel.Info);
    76         if (e.LeftButton == MouseButtonState.Released)
    77         {
    78             GuiLogMessage("Left Mouse Button released", NotificationLevel.Info);
    79             OnPropertyChanged("Output");
    80         }
    8165    }
    8266
     
    8670      {
    8771        output = settings.SetClockToTrue;
    88         if (output) StatusChanged((int)CLKImage.True);
    89         else StatusChanged((int)CLKImage.False);
     72        if (output)
     73        {
     74            StatusChanged((int)CLKImage.True);
     75            cLKPresentation.setImageTrue();
     76        }
     77        else
     78        {
     79            StatusChanged((int)CLKImage.False);
     80            cLKPresentation.setImageFalse();
     81        }
    9082      }
    9183      if (e.PropertyName == "CLKTimeout")
     
    153145    public void PreExecution()
    154146    {
    155         if (settings.SetClockToTrue) StatusChanged((int)CLKImage.True);
    156         else StatusChanged((int)CLKImage.False);
     147        if (settings.SetClockToTrue)
     148        {
     149            StatusChanged((int)CLKImage.True);
     150            cLKPresentation.setImageTrue();
     151        }
     152        else
     153        {
     154            StatusChanged((int)CLKImage.False);
     155            cLKPresentation.setImageFalse();
     156        }
    157157
    158158        myRounds = settings.Rounds;
     
    199199    private void process(int timeout)
    200200    {
    201         // first fire up an event, then get the timer to handle that for us
    202         OnPropertyChanged("Output");
    203         myRounds--;
    204 
    205         // Hook up the Elapsed event for the timer.
    206         aTimer.Elapsed += new ElapsedEventHandler(sendCLKSignal);
    207 
    208         // Set the Interval to 'timeout' seconds (in milliseconds).
    209         aTimer.Interval = timeout;
    210         aTimer.Enabled = true;
    211 
    212         // Keep the timer alive until the end of Main.
    213         //GC.KeepAlive(aTimer);
     201        // check if rounds are more than zero
     202        if (myRounds != 0)
     203        {
     204            // first fire up an event, then get the timer to handle that for us
     205            OnPropertyChanged("Output");
     206            myRounds--;
     207
     208            // Hook up the Elapsed event for the timer.
     209            aTimer.Elapsed += new ElapsedEventHandler(sendCLKSignal);
     210
     211            // Set the Interval to 'timeout' seconds (in milliseconds).
     212            aTimer.Interval = timeout;
     213            aTimer.Enabled = true;
     214
     215            // Keep the timer alive until the end of Main.
     216            //GC.KeepAlive(aTimer);
     217        }
    214218    }
    215219
  • trunk/CrypPlugins/CLK/CLKPresentation.xaml

    r647 r651  
    66        <Grid.RowDefinitions>
    77            <RowDefinition Height="1*" />
    8             <RowDefinition Height="Auto" />
    98        </Grid.RowDefinitions>
    10         <Button Width="32" Height="32" PreviewMouseLeftButtonUp="CLKButtonImage_MouseLeftButtonUp">
    11         <Image Source="icon.png" Stretch="None" Name="CLKButtonImage" HorizontalAlignment="Center" VerticalAlignment="Center" Cursor="Hand" Grid.Row="0" PreviewMouseLeftButtonUp="CLKButtonImage_MouseLeftButtonUp" />
    12             </Button>
    13         <TextBox Name="myTextBox" Grid.Row="1" />
     9       
     10        <!--<Button Width="35" Height="35" Name="CLKButton">
     11            <Image Source="icon.png" Stretch="None" HorizontalAlignment="Center" VerticalAlignment="Center" Cursor="Hand" Grid.Row="0" />
     12        </Button>-->
     13       
     14        <Image Source="icon.png" Stretch="Fill" Name="CLKButtonImage" HorizontalAlignment="Center" VerticalAlignment="Center" Cursor="Hand" Grid.Row="0" Width="32" Height="32" />
     15
    1416    </Grid>
    1517</UserControl>
  • trunk/CrypPlugins/CLK/CLKPresentation.xaml.cs

    r645 r651  
    225225  public partial class CLKPresentation : UserControl
    226226  {
    227     public CLKPresentation()
    228     {
    229       InitializeComponent();
    230       Height = double.NaN;
    231       Width = double.NaN;
    232       myTextBox.Text = "1";
    233     }
    234 
    235     private void CLKButtonImage_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    236     {
    237         myTextBox.Text = "blah";
    238     }
     227      public CLKPresentation()
     228      {
     229          InitializeComponent();
     230          Height = double.NaN;
     231          Width = double.NaN;
     232      }
     233
     234      public void setImageTrue()
     235      {
     236          Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     237          {
     238              BitmapImage png = new BitmapImage();
     239              png.BeginInit();
     240              png.UriSource = new Uri("Images/true.png", UriKind.Relative);
     241              png.EndInit();
     242              CLKButtonImage.Source = png;
     243          }, null);
     244      }
     245
     246      public void setImageFalse()
     247      {
     248          Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     249          {
     250              BitmapImage png = new BitmapImage();
     251              png.BeginInit();
     252              png.UriSource = new Uri("Images/false.png", UriKind.Relative);
     253              png.EndInit();
     254              CLKButtonImage.Source = png;
     255          }, null);
     256      }
    239257  }
    240258}
  • trunk/CrypPlugins/CLK/CLKSettings.cs

    r645 r651  
    9999        set
    100100        {
    101             if (value <= 0) this.rounds = 1;
    102             else this.rounds = value;
     101            /*if (value <= 0)
     102                this.rounds = 1;
     103            else*/
     104                this.rounds = value;
    103105            OnPropertyChanged("Rounds");
    104106            HasChanges = true;
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r645 r651  
    7171        {
    7272            this.settings = new LFSRSettings();
    73             //((LFSRSettings)(this.settings)).LogMessage += LFSR_LogMessage;
     73            settings.PropertyChanged += settings_PropertyChanged;
    7474
    7575            lFSRPresentation = new LFSRPresentation();
     
    7878        }
    7979
     80        void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
     81        {
     82            if (e.PropertyName == "InitLFSR")
     83                preprocessingLFSR();           
     84        }
     85
    8086        public ISettings Settings
    8187        {
     
    8490        }
    8591
    86         [PropertyInfo(Direction.InputData, "TapSequence", "TapSequence function in binary presentation.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     92        [PropertyInfo(Direction.InputData, "TapSequence", "TapSequence function in binary presentation.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    8793        public String InputTapSequence
    8894        {
     
    406412        public void Execute()
    407413        {
    408             lFSRPresentation.DeleteAll(100);
     414            //lFSRPresentation.DeleteAll(100);
    409415            processLFSR();
     416        }
     417
     418        private void preprocessingLFSR()
     419        {
     420            if (checkForInputTapSequence() == 1) return;
     421            if (checkForInputSeed() == 1) return;
     422
     423            /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
     424            {
     425                GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
     426                if (!settings.UseBoolClock) inputClock.Close();
     427                return;
     428            }
     429
     430            if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
     431            {
     432                GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
     433                if (!settings.UseBoolClock) inputClock.Close();
     434                return;
     435            }*/
     436
     437            // read tapSequence
     438            if (settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0))
     439                tapSequencebuffer = inputTapSequence;
     440            else
     441                tapSequencebuffer = settings.Polynomial;
     442
     443            //read seed
     444            if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
     445                seedbuffer = inputSeed;
     446            else
     447                seedbuffer = settings.Seed;
     448
     449            // check if tapSequence is binary
     450            bool tapSeqisBool = true;
     451            foreach (char character in tapSequencebuffer)
     452            {
     453                if (character != '0' && character != '1')
     454                {
     455                    tapSeqisBool = false;
     456                    //return;
     457                }
     458            }
     459
     460            // if tapSequence is not binary, await polynomial
     461            if (!tapSeqisBool)
     462            {
     463                GuiLogMessage("TapSequence is not binary. Awaiting polynomial.", NotificationLevel.Info);
     464                if (IsPolynomial(tapSequencebuffer))
     465                {
     466                    GuiLogMessage(tapSequencebuffer + " is a valid polynomial.", NotificationLevel.Info);
     467                    tapSequencebuffer = MakeBinary(tapSequencebuffer);
     468                    GuiLogMessage("Polynomial in binary form: " + tapSequencebuffer, NotificationLevel.Info);
     469
     470                    // check if polynomial has false length
     471                    if (tapSequencebuffer.Length != seedbuffer.Length)
     472                    {
     473                        /*// check if its too long
     474                        if (inputSeed.Length - tapSequencebuffer.Length < 0)
     475                        {
     476                            GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " is TOO LONG (" + tapSequencebuffer.Length + " Bits) for your seed. Aborting now.", NotificationLevel.Error);
     477                            if (!settings.UseBoolClock) inputClock.Close();
     478                            return;
     479                        }
     480                        // seems to be too short, so fill it with zeros at the beginning
     481                        else
     482                        {
     483                            for (int j = inputSeed.Length - tapSequencebuffer.Length; j > 0; j--)
     484                            {
     485                                tapSequencebuffer = "0" + tapSequencebuffer;
     486                            }
     487                        }*/
     488                        GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " has to be the same length (" + tapSequencebuffer.Length + " Bits) as your seed (" + seedbuffer.Length + " Bits). Aborting now.", NotificationLevel.Error);
     489                        Dispose();
     490                        return;
     491                    }
     492
     493                    //GuiLogMessage("Polynomial after length fitting: " + tapSequencebuffer, NotificationLevel.Info);
     494                }
     495                else
     496                {
     497                    GuiLogMessage("ERROR - " + tapSequencebuffer + " is NOT a valid polynomial. Aborting now.", NotificationLevel.Error);
     498                    //Console.WriteLine("\n{0} is NOT a valid polynomial.", tapSequencebuffer);
     499                    Dispose();
     500                    return;
     501                }
     502            }
     503
     504            // convert tapSequence into char array
     505            //tapSequenceCharArray = ReverseOrder(tapSequencebuffer.ToCharArray());
     506            tapSequenceCharArray = tapSequencebuffer.ToCharArray();
     507
     508            if (tapSequencebuffer.Length != seedbuffer.Length)
     509            {
     510                // stop, because seed and tapSequence must have same length
     511                GuiLogMessage("ERROR - Seed and tapSequence must have same length. Aborting now.", NotificationLevel.Error);
     512                Dispose();
     513                return;
     514            }
     515
     516            int tapSequenceBits = tapSequencebuffer.Length;
     517            seedBits = seedbuffer.Length;
     518
     519            GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug);
     520            GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug);
     521
     522            //check if last tap is 1, otherwise stop
     523            if (tapSequenceCharArray[tapSequenceCharArray.Length - 1] == '0')
     524            {
     525                GuiLogMessage("ERROR - Last tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
     526                return;
     527            }
     528
     529            // convert seed into char array
     530            seedCharArray = seedbuffer.ToCharArray();
     531
     532            // check if seed is binary
     533            foreach (char character in seedCharArray)
     534            {
     535                if (character != '0' && character != '1')
     536                {
     537                    GuiLogMessage("ERROR 0 - Seed has to be binary. Aborting now. Character is: " + character, NotificationLevel.Error);
     538                    return;
     539                }
     540            }
     541            if (settings.UseAdditionalOutputBit)
     542            {
     543                if (settings.ClockingBit < seedCharArray.Length) clocking = (seedCharArray.Length - settings.ClockingBit - 1);
     544                else
     545                {
     546                    clocking = -1;
     547                    GuiLogMessage("WARNING: Clocking Bit is too high. Ignored.", NotificationLevel.Warning);
     548                }
     549
     550            }
     551            else clocking = -1;
     552
     553            /*// check which clock to use
     554            if (settings.UseBoolClock)
     555            {
     556                myClock = inputClockBool;
     557            }
     558            else if (!settings.UseBoolClock)
     559            {
     560                // read stream clock
     561                checkForInputClock();
     562                inputClock.OpenWrite("LFSR Restart");
     563                String stringClock = inputClock.ReadByte().ToString();
     564                inputClock.Position = 0;
     565                if (String.Equals(stringClock, "49")) myClock = true; else myClock = false;
     566                //inputClock.Close();
     567            }*/
     568
     569            // check if Rounds are given
     570            int defaultRounds = 10;
     571
     572            // check if Rounds in settings are given and use them only if no bool clock is selected
     573            if (!settings.UseBoolClock)
     574            {
     575                if (settings.Rounds == 0) actualRounds = defaultRounds; else actualRounds = settings.Rounds;
     576            }
     577            else actualRounds = 1;
     578
     579            // draw LFSR Quickwatch
     580            if (!settings.NoQuickwatch)
     581            {
     582                lFSRPresentation.DeleteAll(100);
     583                lFSRPresentation.DrawLFSR(seedCharArray, tapSequenceCharArray, clocking);
     584                lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, ' ', BuildPolynomialFromBinary(tapSequenceCharArray));
     585            }
    410586        }
    411587
     
    447623                if (newSeed)
    448624                {
    449                     if (checkForInputTapSequence() == 1) return;
    450                     if (checkForInputSeed() == 1) return;
    451 
    452                     /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
    453                     {
    454                         GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
    455                         if (!settings.UseBoolClock) inputClock.Close();
    456                         return;
    457                     }
    458 
    459                     if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
    460                     {
    461                         GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
    462                         if (!settings.UseBoolClock) inputClock.Close();
    463                         return;
    464                     }*/
    465 
    466                     // read tapSequence
    467                     if (settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0))
    468                         tapSequencebuffer = inputTapSequence;
    469                     else
    470                         tapSequencebuffer = settings.Polynomial;
    471 
    472                     //read seed
    473                     if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
    474                         seedbuffer = inputSeed;
    475                     else
    476                         seedbuffer = settings.Seed;
    477 
    478                     // check if tapSequence is binary
    479                     bool tapSeqisBool = true;
    480                     foreach (char character in tapSequencebuffer)
    481                     {
    482                         if (character != '0' && character != '1')
    483                         {
    484                             tapSeqisBool = false;
    485                             //return;
    486                         }
    487                     }
    488 
    489                     // if tapSequence is not binary, await polynomial
    490                     if (!tapSeqisBool)
    491                     {
    492                         GuiLogMessage("TapSequence is not binary. Awaiting polynomial.", NotificationLevel.Info);
    493                         if (IsPolynomial(tapSequencebuffer))
    494                         {
    495                             GuiLogMessage(tapSequencebuffer + " is a valid polynomial.", NotificationLevel.Info);
    496                             tapSequencebuffer = MakeBinary(tapSequencebuffer);
    497                             GuiLogMessage("Polynomial in binary form: " + tapSequencebuffer, NotificationLevel.Info);
    498 
    499                             // check if polynomial has false length
    500                             if (tapSequencebuffer.Length != seedbuffer.Length)
    501                             {
    502                                 /*// check if its too long
    503                                 if (inputSeed.Length - tapSequencebuffer.Length < 0)
    504                                 {
    505                                     GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " is TOO LONG (" + tapSequencebuffer.Length + " Bits) for your seed. Aborting now.", NotificationLevel.Error);
    506                                     if (!settings.UseBoolClock) inputClock.Close();
    507                                     return;
    508                                 }
    509                                 // seems to be too short, so fill it with zeros at the beginning
    510                                 else
    511                                 {
    512                                     for (int j = inputSeed.Length - tapSequencebuffer.Length; j > 0; j--)
    513                                     {
    514                                         tapSequencebuffer = "0" + tapSequencebuffer;
    515                                     }
    516                                 }*/
    517                                 GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " has to be the same length (" + tapSequencebuffer.Length + " Bits) as your seed (" + seedbuffer.Length + " Bits). Aborting now.", NotificationLevel.Error);
    518                                 Dispose();
    519                                 return;
    520                             }
    521 
    522                             //GuiLogMessage("Polynomial after length fitting: " + tapSequencebuffer, NotificationLevel.Info);
    523                         }
    524                         else
    525                         {
    526                             GuiLogMessage("ERROR - " + tapSequencebuffer + " is NOT a valid polynomial. Aborting now.", NotificationLevel.Error);
    527                             //Console.WriteLine("\n{0} is NOT a valid polynomial.", tapSequencebuffer);
    528                             Dispose();
    529                             return;
    530                         }
    531                     }
    532 
    533                     // convert tapSequence into char array
    534                     //tapSequenceCharArray = ReverseOrder(tapSequencebuffer.ToCharArray());
    535                     tapSequenceCharArray = tapSequencebuffer.ToCharArray();
    536 
    537                     if (tapSequencebuffer.Length != seedbuffer.Length)
    538                     {
    539                         // stop, because seed and tapSequence must have same length
    540                         GuiLogMessage("ERROR - Seed and tapSequence must have same length. Aborting now.", NotificationLevel.Error);
    541                         Dispose();
    542                         return;
    543                     }
    544 
    545                     int tapSequenceBits = tapSequencebuffer.Length;
    546                     seedBits = seedbuffer.Length;
    547 
    548                     GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug);
    549                     GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug);
    550 
    551                     //check if last tap is 1, otherwise stop
    552                     if (tapSequenceCharArray[tapSequenceCharArray.Length - 1] == '0')
    553                     {
    554                         GuiLogMessage("ERROR - Last tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
    555                         return;
    556                     }
    557 
    558                     // convert seed into char array
    559                     seedCharArray = seedbuffer.ToCharArray();
    560 
    561                     // check if seed is binary
    562                     foreach (char character in seedCharArray)
    563                     {
    564                         if (character != '0' && character != '1')
    565                         {
    566                             GuiLogMessage("ERROR 0 - Seed has to be binary. Aborting now. Character is: " + character, NotificationLevel.Error);
    567                             return;
    568                         }
    569                     }
    570                     if (settings.UseAdditionalOutputBit)
    571                     {
    572                         if (settings.ClockingBit < seedCharArray.Length) clocking = (seedCharArray.Length - settings.ClockingBit - 1);
    573                         else
    574                         {
    575                             clocking = -1;
    576                             GuiLogMessage("WARNING: Clocking Bit is too high. Ignored.", NotificationLevel.Warning);
    577                         }
    578 
    579                     }
    580                     else clocking = -1;
    581 
    582                     /*// check which clock to use
    583                     if (settings.UseBoolClock)
    584                     {
    585                         myClock = inputClockBool;
    586                     }
    587                     else if (!settings.UseBoolClock)
    588                     {
    589                         // read stream clock
    590                         checkForInputClock();
    591                         inputClock.OpenWrite("LFSR Restart");
    592                         String stringClock = inputClock.ReadByte().ToString();
    593                         inputClock.Position = 0;
    594                         if (String.Equals(stringClock, "49")) myClock = true; else myClock = false;
    595                         //inputClock.Close();
    596                     }*/
    597 
    598                     // check if Rounds are given
    599                     int defaultRounds = 10;
    600 
    601                     // check if Rounds in settings are given and use them only if no bool clock is selected
    602                     if (!settings.UseBoolClock)
    603                     {
    604                         if (settings.Rounds == 0) actualRounds = defaultRounds; else actualRounds = settings.Rounds;
    605                     }
    606                     else actualRounds = 1;
     625                    preprocessingLFSR();
    607626                }
    608627               
     
    618637                }
    619638
    620                 // draw LFSR Quickwatch
     639                // (re-)draw LFSR Quickwatch
    621640                if (!settings.NoQuickwatch)
    622641                {
     642                    lFSRPresentation.DeleteAll(100);
    623643                    lFSRPresentation.DrawLFSR(seedCharArray, tapSequenceCharArray, clocking);
    624644                }
     
    627647                outputStream = new CryptoolStream();
    628648                listCryptoolStreamsOut.Add(outputStream);
    629                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     649                outputStream.OpenWrite();
    630650
    631651                //GuiLogMessage("Action is: Now!", NotificationLevel.Debug);
  • trunk/CrypPlugins/LFSR/LFSRSettings.cs

    r645 r651  
    2424
    2525        private bool hasChanges = false;
     26
     27        [TaskPane("Draw LFSR", "Initializes LFSR and draws the presentation. This is used to view the LFSR before pressing play.", null, 0, false, DisplayLevel.Beginner, ControlType.Button)]
     28        public void initLFSR()
     29        {
     30            OnPropertyChanged("InitLFSR");
     31        }
    2632       
    2733        private int rounds = 1; //how many bits will be generated
  • trunk/CrypPlugins/NLFSR/NLFSR.cs

    r645 r651  
    7272        {
    7373            this.settings = new NLFSRSettings();
    74             //((NLFSRSettings)(this.settings)).LogMessage += NLFSR_LogMessage;
     74            settings.PropertyChanged += settings_PropertyChanged;
    7575
    7676            NLFSRPresentation = new NLFSRPresentation();
     
    7979        }
    8080
     81        void settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
     82        {
     83            if (e.PropertyName == "InitNLFSR")
     84                preprocessNLFSR();
     85        }
     86
    8187        public ISettings Settings
    8288        {
     
    8591        }
    8692
    87         [PropertyInfo(Direction.InputData, "TapSequence", "TapSequence function in binary presentation.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     93        [PropertyInfo(Direction.InputData, "TapSequence", "TapSequence function in binary presentation.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    8894        public String InputTapSequence
    8995        {
     
    523529        public void Execute()
    524530        {
    525             NLFSRPresentation.DeleteAll(100);
     531            //NLFSRPresentation.DeleteAll(100);
    526532            processNLFSR();
     533        }
     534
     535        private void preprocessNLFSR()
     536        {
     537            if (checkForInputTapSequence() == 1) return;
     538            if (checkForInputSeed() == 1) return;
     539
     540            /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
     541            {
     542                GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
     543                if (!settings.UseBoolClock) inputClock.Close();
     544                return;
     545            }
     546
     547            if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
     548            {
     549                GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
     550                if (!settings.UseBoolClock) inputClock.Close();
     551                return;
     552            }*/
     553
     554            // read tapSequence
     555            if (settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0))
     556                tapSequencebuffer = inputTapSequence;
     557            else
     558                tapSequencebuffer = settings.Polynomial;
     559
     560            //read seed
     561            if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
     562                seedbuffer = inputSeed;
     563            else
     564                seedbuffer = settings.Seed;
     565
     566            // convert tapSequence into char array
     567            //tapSequenceCharArray = ReverseOrder(tapSequencebuffer.ToCharArray());
     568            tapSequenceCharArray = tapSequencebuffer.ToCharArray();
     569
     570            int tapSequenceBits = tapSequencebuffer.Length;
     571            seedBits = seedbuffer.Length;
     572
     573            GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug);
     574            GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug);
     575
     576            //check if last tap is 1, otherwise stop
     577            /*if (tapSequenceCharArray[tapSequenceCharArray.Length - 1] == '0')
     578            {
     579                GuiLogMessage("ERROR - Last tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
     580                return;
     581            }*/
     582
     583            // convert seed into char array
     584            seedCharArray = seedbuffer.ToCharArray();
     585
     586            // check if seed is binary
     587            for (int z = 0; z < seedCharArray.Length; z++)
     588            {
     589                if (seedCharArray[z] != '0' && seedCharArray[z] != '1')
     590                {
     591                    GuiLogMessage("ERROR 0 - Seed has to be binary. Aborting now. Character is: " + seedCharArray[z], NotificationLevel.Error);
     592                    return;
     593                }
     594                // create tapSequence for drawing NLFSR
     595                string temp = "x^" + z;
     596                if (tapSequencebuffer.Contains(temp))
     597                {
     598                    tapSequenceCharArray[((z - seedCharArray.Length) * -1) - 1] = '1';
     599                }
     600                else
     601                    tapSequenceCharArray[((z - seedCharArray.Length) * -1) - 1] = '0';
     602            }
     603
     604            if (settings.UseClockingBit)
     605            {
     606                if (settings.ClockingBit < seedCharArray.Length) clocking = (seedCharArray.Length - settings.ClockingBit - 1);
     607                else
     608                {
     609                    clocking = -1;
     610                    GuiLogMessage("WARNING: Clocking Bit is too high. Ignored.", NotificationLevel.Warning);
     611                }
     612
     613            }
     614            else clocking = -1;
     615
     616            // check if Rounds are given
     617            int defaultRounds = 10;
     618
     619            // check if Rounds in settings are given and use them only if no bool clock is selected
     620            if (!settings.UseBoolClock)
     621            {
     622                if (settings.Rounds == 0) actualRounds = defaultRounds; else actualRounds = settings.Rounds;
     623            }
     624            else actualRounds = 1;
     625
     626            // draw presentation
     627            // (re-)draw NLFSR Quickwatch
     628            if (!settings.NoQuickwatch)
     629            {
     630                NLFSRPresentation.DeleteAll(100);
     631                NLFSRPresentation.DrawNLFSR(seedCharArray, tapSequenceCharArray, clocking);
     632                NLFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, ' ', tapSequencebuffer);
     633            }
    527634        }
    528635
     
    563670                if (newSeed)
    564671                {
    565                     if (checkForInputTapSequence() == 1) return;
    566                     if (checkForInputSeed() == 1) return;
    567 
    568                     /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
    569                     {
    570                         GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
    571                         if (!settings.UseBoolClock) inputClock.Close();
    572                         return;
    573                     }
    574 
    575                     if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
    576                     {
    577                         GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
    578                         if (!settings.UseBoolClock) inputClock.Close();
    579                         return;
    580                     }*/
    581 
    582                     // read tapSequence
    583                     if (settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0))
    584                         tapSequencebuffer = inputTapSequence;
    585                     else
    586                         tapSequencebuffer = settings.Polynomial;
    587 
    588                     //read seed
    589                     if (settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0))
    590                         seedbuffer = inputSeed;
    591                     else
    592                         seedbuffer = settings.Seed;
    593 
    594                     // convert tapSequence into char array
    595                     //tapSequenceCharArray = ReverseOrder(tapSequencebuffer.ToCharArray());
    596                     tapSequenceCharArray = tapSequencebuffer.ToCharArray();
    597 
    598                     int tapSequenceBits = tapSequencebuffer.Length;
    599                     seedBits = seedbuffer.Length;
    600 
    601                     GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug);
    602                     GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug);
    603 
    604                     //check if last tap is 1, otherwise stop
    605                     /*if (tapSequenceCharArray[tapSequenceCharArray.Length - 1] == '0')
    606                     {
    607                         GuiLogMessage("ERROR - Last tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
    608                         return;
    609                     }*/
    610 
    611                     // convert seed into char array
    612                     seedCharArray = seedbuffer.ToCharArray();
    613 
    614                     // check if seed is binary
    615                     for (int z = 0; z < seedCharArray.Length; z++)
    616                     {
    617                         if (seedCharArray[z] != '0' && seedCharArray[z] != '1')
    618                         {
    619                             GuiLogMessage("ERROR 0 - Seed has to be binary. Aborting now. Character is: " + seedCharArray[z], NotificationLevel.Error);
    620                             return;
    621                         }
    622                         // create tapSequence for drawing NLFSR
    623                         string temp = "x^" + z;
    624                         if (tapSequencebuffer.Contains(temp))
    625                         {
    626                             tapSequenceCharArray[((z - seedCharArray.Length) * -1)-1] = '1';
    627                         }
    628                         else
    629                             tapSequenceCharArray[((z - seedCharArray.Length) * -1)-1] = '0';
    630                     }
    631 
    632                     if (settings.UseClockingBit)
    633                     {
    634                         if (settings.ClockingBit < seedCharArray.Length) clocking = (seedCharArray.Length - settings.ClockingBit - 1);
    635                         else
    636                         {
    637                             clocking = -1;
    638                             GuiLogMessage("WARNING: Clocking Bit is too high. Ignored.", NotificationLevel.Warning);
    639                         }
    640 
    641                     }
    642                     else clocking = -1;
    643 
    644                     // check if Rounds are given
    645                     int defaultRounds = 10;
    646 
    647                     // check if Rounds in settings are given and use them only if no bool clock is selected
    648                     if (!settings.UseBoolClock)
    649                     {
    650                         if (settings.Rounds == 0) actualRounds = defaultRounds; else actualRounds = settings.Rounds;
    651                     }
    652                     else actualRounds = 1;
    653 
    654                     // create tapSequence for drawing NLFSR
     672                    preprocessNLFSR();
    655673                }
    656674               
    657675                // Here we go!
    658                 // draw NLFSR Quickwatch
     676                // (re-)draw NLFSR Quickwatch
    659677                if (!settings.NoQuickwatch)
    660678                {
     679                    NLFSRPresentation.DeleteAll(100);
    661680                    NLFSRPresentation.DrawNLFSR(seedCharArray, tapSequenceCharArray, clocking);
    662681                }
  • trunk/CrypPlugins/NLFSR/NLFSRSettings.cs

    r645 r651  
    2323
    2424        private bool hasChanges = false;
     25
     26        [TaskPane("Draw NLFSR", "Initializes NLFSR and draws the presentation. This is used to view the NLFSR before pressing play.", null, 0, false, DisplayLevel.Beginner, ControlType.Button)]
     27        public void initNLFSR()
     28        {
     29            OnPropertyChanged("InitNLFSR");
     30        }
    2531       
    2632        private int rounds = 1; //how many bits will be generated
  • trunk/ProjectSamples

    • Property svn:ignore set to
      MASamples.lnk
Note: See TracChangeset for help on using the changeset viewer.