Changeset 375


Ignore:
Timestamp:
Jul 2, 2009, 2:32:26 PM (13 years ago)
Author:
Sören Rinne
Message:
  • tuned LFSR and BFP for Dagstuhl presentation
Location:
trunk/CrypPlugins
Files:
4 edited

Legend:

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

    r331 r375  
    2727        private BooleanFunctionParserSettings settings;
    2828        private string inputFunction;
    29         private bool inputVariableOne;
    30         private bool inputVariableTwo;
     29        private bool[] inputVariableOne;
     30        private bool[] inputVariableTwo;
    3131        private bool[] inputVariableThree;
    3232        private bool output;
     33        private bool lastInputWasFunction = false;
    3334
    3435        #endregion
     
    3637        #region Public variables
    3738
    38         public int inputOneFlag;
    39         public int inputTwoFlag;
    40         public int inputThreeFlag;
     39        public int inputOneFlag = 0;
     40        public int inputTwoFlag = 0;
     41        public int inputThreeFlag = 0;
    4142
    4243        #endregion
     
    6263            {
    6364                inputFunction = value;
     65                lastInputWasFunction = true;
    6466                OnPropertyChanged("InputFunction");
    6567            }
    6668        }
    6769
    68         [PropertyInfo(Direction.Input, "Function Variable One (i_1)", "Input a boolean value to be processed by the function", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    69         public bool InputOne
     70        [PropertyInfo(Direction.Input, "Function Variable One (i_1.j)", "Input a boolean value to be processed by the function", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     71        public bool[] InputOne
    7072        {
    7173            [MethodImpl(MethodImplOptions.Synchronized)]
     
    8385            {
    8486                this.inputVariableOne = value;
     87                lastInputWasFunction = false;
    8588                OnPropertyChanged("InputOne");
    8689                // clean inputOne
     
    8992        }
    9093
    91         [PropertyInfo(Direction.Input, "Function Variable Two (i_2)", "Input a boolean value to be processed by the function", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    92         public bool InputTwo
     94        [PropertyInfo(Direction.Input, "Function Variable Two (i_2.j)", "Input a boolean value to be processed by the function", "", false, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     95        public bool[] InputTwo
    9396        {
    9497            [MethodImpl(MethodImplOptions.Synchronized)]
     
    107110            {
    108111                this.inputVariableTwo = value;
     112                lastInputWasFunction = false;
    109113                OnPropertyChanged("InputTwo");
    110114                // clean inputOne
     
    113117        }
    114118
    115         [PropertyInfo(Direction.Input, "Function Variable Three (i_3j)", "Input a boolean value to be processed by the function", "", true, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     119        [PropertyInfo(Direction.Input, "Function Variable Three (i_3.j)", "Input a boolean value to be processed by the function", "", true, true, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    116120        public bool[] InputThree
    117121        {
     
    131135            {
    132136                this.inputVariableThree = value;
     137                lastInputWasFunction = false;
    133138                OnPropertyChanged("InputThree");
    134139                // clean inputOne
     
    163168            try
    164169            {
    165                 // get function from input and replace variables
    166                 string strExpression = ReplaceVariables(inputFunction);
    167                 // test if function is valid
    168                 string strExpressionTested = TestFunction(strExpression);
    169                 if (strExpressionTested == "foo")
    170                 {
    171                     GuiLogMessage(strExpression + " is not a binary expression (e.g. 1 + 0 * 1). Aborting now.", NotificationLevel.Error);
    172                     return;
    173                 }
    174                 else
    175                 {
    176                     GuiLogMessage("Your expression with variables replaced: " + strExpression, NotificationLevel.Info);
    177                     output = EvaluateTree(output, FillTree(strExpressionTested));
    178                     OnPropertyChanged("Output");
     170                // do calculation only, if last event wasn't from the function input
     171                if (lastInputWasFunction == false)
     172                {
     173                    // get function from input and replace variables
     174                    string strExpression = ReplaceVariables(inputFunction);
     175                    // test if function is valid
     176                    string strExpressionTested = TestFunction(strExpression);
     177                    if (strExpressionTested == "foo")
     178                    {
     179                        GuiLogMessage(strExpression + " is not a binary expression (e.g. 1 + 0 * 1). Aborting now.", NotificationLevel.Error);
     180                        return;
     181                    }
     182                    else
     183                    {
     184                        GuiLogMessage("Your expression with variables replaced: " + strExpression, NotificationLevel.Info);
     185                        output = EvaluateTree(output, FillTree(strExpressionTested));
     186                        OnPropertyChanged("Output");
     187                    }
    179188                }
    180189            }
     
    225234        private string ReplaceVariables(string strExpressionWithVariables)
    226235        {
    227             string strExpression;
    228             string strInputVariableOne, strInputVariableTwo;
    229             char[] strInputVariableThree = new char[inputVariableThree.Length];
    230 
    231             // get numeric values from bool inputs
    232             if (inputVariableOne) strInputVariableOne = "1"; else strInputVariableOne = "0";
    233             if (inputVariableTwo) strInputVariableTwo = "1"; else strInputVariableTwo = "0";
    234             //if (inputVariableThree) strInputVariableThree = "1"; else strInputVariableThree = "0";
    235             for (int i = 0; i < inputVariableThree.Length; i++)
    236             {
    237                 strInputVariableThree[i] = inputVariableThree[i] ? '1' : '0';
    238             }
    239 
    240             // replace variables with value
    241             strExpression = strExpressionWithVariables.Replace("i_1", strInputVariableOne);
    242             strExpression = strExpression.Replace("i_2", strInputVariableTwo);
    243             for (int i = 0; i < inputVariableThree.Length; i++)
    244             {
    245                 string replacement = "i_3" + i;
    246                 strExpression = strExpression.Replace(replacement, strInputVariableThree[i].ToString());
    247             }
    248             //strExpression = strExpression.Replace("i_3", strInputVariableThree);
     236            string strExpression = strExpressionWithVariables;
     237
     238            // replace variables with value and get numeric values from bool inputs
     239            if (inputOneFlag == 1)
     240            {
     241                char[] strInputVariableOne = new char[inputVariableOne.Length];
     242                for (int i = 0; i < inputVariableOne.Length; i++)
     243                {
     244                    // get numeric values from bool inputs
     245                    strInputVariableOne[i] = inputVariableOne[i] ? '1' : '0';
     246                    // replace variables with value
     247                    string replacement = "i_1." + i;
     248                    strExpression = strExpression.Replace(replacement, strInputVariableOne[i].ToString());
     249                }
     250            }
     251            if (inputTwoFlag == 1)
     252            {
     253                char[] strInputVariableTwo = new char[inputVariableTwo.Length];
     254                for (int i = 0; i < inputVariableTwo.Length; i++)
     255                {
     256                    // get numeric values from bool inputs
     257                    strInputVariableTwo[i] = inputVariableTwo[i] ? '1' : '0';
     258                    string replacement = "i_2." + i;
     259                    strExpression = strExpression.Replace(replacement, strInputVariableTwo[i].ToString());
     260                }
     261            }
     262            if (inputThreeFlag == 1)
     263            {
     264                char[] strInputVariableThree = new char[inputVariableThree.Length];
     265                for (int i = 0; i < inputVariableThree.Length; i++)
     266                {
     267                    // get numeric values from bool inputs
     268                    strInputVariableThree[i] = inputVariableThree[i] ? '1' : '0';
     269                    string replacement = "i_3." + i;
     270                    strExpression = strExpression.Replace(replacement, strInputVariableThree[i].ToString());
     271                }
     272            }
     273           
    249274
    250275            // replace AND, NAND, OR, NOR, XOR, NXOR with symbols
  • trunk/CrypPlugins/BooleanFunctionParser/DetailedDescription/Description.xaml

    r335 r375  
    6464  </Paragraph>
    6565  <Paragraph Background="#F2F2F2" Padding="2" FontSize="10" FontFamily="Courier New">
    66       i_1<Run Foreground="#A21A17">0</Run> * i_1<Run Foreground="#A21A17">1</Run>
     66      i_1<Run Foreground="#A21A17">.0</Run> * i_1<Run Foreground="#A21A17">.1</Run>
    6767  </Paragraph>
    6868  </Section>
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r371 r375  
    2525{
    2626    [Author("Soeren Rinne", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for System Security", "http://www.trust.rub.de/")]
    27     [PluginInfo(true, "LFSR", "Linear Feedback Shift Register", "LFSR/DetailedDescription/Description.xaml", "LFSR/Images/LFSR.png", "LFSR/Images/encrypt.png", "LFSR/Images/decrypt.png")]
     27    [PluginInfo(false, "LFSR", "Linear Feedback Shift Register", "LFSR/DetailedDescription/Description.xaml", "LFSR/Images/LFSR.png", "LFSR/Images/encrypt.png", "LFSR/Images/decrypt.png")]
    2828    [EncryptionType(EncryptionType.SymmetricBlock)]
    2929    public class LFSR : IThroughput
     
    3434        private String inputTapSequence;
    3535        private String inputSeed;
    36         private CryptoolStream inputClock;
    3736        private CryptoolStream outputStream;
    3837        private String outputString;
    3938        private bool outputBool;
    40         private bool inputClockBool;
     39        private bool inputClockBool = true;
    4140        private bool outputClockingBit;
    4241       
     
    8483        }
    8584
    86         [PropertyInfo(Direction.Input, "TapSequence", "TapSequence function in binary presentation.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     85        [PropertyInfo(Direction.Input, "TapSequence", "TapSequence function in binary presentation.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    8786        public String InputTapSequence
    8887        {
     
    9897        }
    9998
    100         [PropertyInfo(Direction.Input, "Seed", "Seed of the LFSR in binary presentation.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     99        [PropertyInfo(Direction.Input, "Seed", "Seed of the LFSR in binary presentation.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    101100        public String InputSeed
    102101        {
     
    200199                outputString = null;
    201200                outputStringBuffer = null;
    202                 inputClock = null;
    203201                inputTapSequence = null;
    204202                inputSeed = null;
    205 
    206                 if (inputClock != null)
    207                 {
    208                     inputClock.Flush();
    209                     inputClock.Close();
    210                     inputClock = null;
    211                 }
    212203
    213204                if (outputStream != null)
     
    234225        #region private functions
    235226
    236         private bool checkForInputTapSequence()
    237         {
    238             if ((settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0)))
     227        private int checkForInputTapSequence()
     228        {
     229            /*if ((settings.Polynomial == null || (settings.Polynomial != null && settings.Polynomial.Length == 0)))
    239230            {
    240231                // awaiting polynomial from input
    241232                GuiLogMessage("No feedback polynomial given in settings. Awaiting external input.", NotificationLevel.Info);
    242                 /*GuiLogMessage("No feedback polynomial given in settings.", NotificationLevel.Error);
    243                 if (!settings.UseBoolClock) inputClock.Close();
    244                 return;*/
    245233            }
    246234            else
    247235            {
    248236                inputTapSequence = settings.Polynomial;
    249                 return true;
    250             }
     237                return 1;
     238            }*/
    251239
    252240            if ((inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0)))
     
    258246                // write a warning to the outside world
    259247                GuiLogMessage("WARNING - No TapSequence provided. Using dummy data (" + dummystring + ").", NotificationLevel.Warning);
    260                 return true;
     248                return 1;
    261249            }
    262250            else
    263251            {
    264                 return false;
    265             }
    266         }
    267 
    268         private bool checkForInputSeed()
    269         {
    270             if ((settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0)))
     252                return 0;
     253            }
     254        }
     255
     256        private int checkForInputSeed()
     257        {
     258            /*if ((settings.Seed == null || (settings.Seed != null && settings.Seed.Length == 0)))
    271259            {
    272260                // awaiting seed from input
    273261                GuiLogMessage("No seed given in settings. Awaiting external input.", NotificationLevel.Info);
    274                 /*GuiLogMessage("No seed given in settings.", NotificationLevel.Error);
    275                 if (!settings.UseBoolClock) inputClock.Close();
    276                 return;*/
    277262            }
    278263            else
    279264            {
    280265                inputSeed = settings.Seed;
    281                 return true;
    282             }
     266                return 1;
     267            }*/
    283268
    284269            if ((inputSeed == null || (inputSeed != null && inputSeed.Length == 0)))
     
    290275                // write a warning to the outside world
    291276                GuiLogMessage("WARNING - No Seed provided. Using dummy data (" + dummystring + ").", NotificationLevel.Warning);
    292                 return true;
     277                return 1;
    293278            }
    294279            else
    295280            {
    296                 return false;
    297             }
    298         }
    299 
    300         private void checkForInputClock()
    301         {
    302             if ((inputClock == null || (inputClock != null && inputClock.Length == 0)))
    303             {
    304                 //create some input
    305                 String dummystring = "1";
    306                 this.inputClock = new CryptoolStream();
    307                 this.inputClock.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
    308                 // write a warning to the outside world
    309                 GuiLogMessage("FYI - No clock input provided. Assuming number of rounds specified in LFSR settings.", NotificationLevel.Info);
     281                return 0;
    310282            }
    311283        }
     
    461433                if (newSeed)
    462434                {
    463                     if (!checkForInputTapSequence()) return;
    464                     if (!checkForInputSeed()) return;
     435                    if (checkForInputTapSequence() == 1) return;
     436                    if (checkForInputSeed() == 1) return;
    465437
    466438                    /*if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
     
    521493                                }*/
    522494                                GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " has to be the same length (" + tapSequencebuffer.Length + " Bits) as your seed (" + inputSeed.Length + " Bits). Aborting now.", NotificationLevel.Error);
    523                                 if (!settings.UseBoolClock) inputClock.Close();
     495                                Dispose();
    524496                                return;
    525497                            }
     
    531503                            GuiLogMessage("ERROR - " + tapSequencebuffer + " is NOT a valid polynomial. Aborting now.", NotificationLevel.Error);
    532504                            //Console.WriteLine("\n{0} is NOT a valid polynomial.", tapSequencebuffer);
    533                             if (!settings.UseBoolClock) inputClock.Close();
     505                            Dispose();
    534506                            return;
    535507                        }
     
    544516                        // stop, because seed and tapSequence must have same length
    545517                        GuiLogMessage("ERROR - Seed and tapSequence must have same length. Aborting now.", NotificationLevel.Error);
    546                         if (!settings.UseBoolClock) inputClock.Close();
     518                        Dispose();
    547519                        return;
    548520                    }
     
    577549                        }
    578550                    }
    579                     if (settings.UseClockingBit)
     551                    if (settings.UseAdditionalOutputBit)
    580552                    {
    581553                        if (settings.ClockingBit < seedCharArray.Length) clocking = (seedCharArray.Length - settings.ClockingBit - 1);
     
    624596                else if (!settings.UseBoolClock)
    625597                {
    626                     // read stream clock
    627                     checkForInputClock();
    628                     inputClock.OpenWrite("LFSR Restart");
    629                     String stringClock = inputClock.ReadByte().ToString();
    630                     inputClock.Position = 0;
    631                     if (String.Equals(stringClock, "49")) myClock = true; else myClock = false;
    632                     //inputClock.Close();
     598                    myClock = true;
    633599                }
    634600
     
    730696                            // but nevertheless fire an output event with dirty value / old value
    731697                            /////////
    732                             if (settings.CreateDirtyOutputOnFalseClock)
     698                            //TODO: revert comment, if there will be a dirty output again
     699                            /*if (settings.CreateDirtyOutputOnFalseClock)
    733700                            {
    734701                                outputBool = false;
     
    746713                            }
    747714                            else
    748                             {
     715                            {*/
    749716                                // make bool output
    750717                                if (seedCharArray[seedBits - 1] == '0') outputBool = false;
     
    764731                                    lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, seedCharArray[seedBits - 1], BuildPolynomialFromBinary(tapSequenceCharArray));
    765732                                }
    766                             }
     733                            //}
    767734                            /////////
    768735                        }
     
    779746                        //return;
    780747                    }
    781                     // in both cases update "clocking bit" if set in settings
    782                     if (settings.UseClockingBit)
     748                    // in both cases update additional output bit if set in settings
     749                    if (settings.UseAdditionalOutputBit)
    783750                    {
    784751                        // make clocking bit output only if its not out of bounds
     
    813780                    GuiLogMessage("Time used: " + duration, NotificationLevel.Debug);
    814781                    outputStream.Close();
    815                     if (!settings.UseBoolClock) inputClock.Close();
    816782                    OnPropertyChanged("OutputStream");
    817783                }
     
    820786                {
    821787                    outputStream.Close();
    822                     if (!settings.UseBoolClock) inputClock.Close();
    823788                    GuiLogMessage("Aborted!", NotificationLevel.Debug);
    824789                }
  • trunk/CrypPlugins/LFSR/LFSRSettings.cs

    r371 r375  
    2525        //[ContextMenu("Rounds", "How many bits shall be generated?", 1, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, new int[] { 10, 50, 100 }, "10 bits", "50 bits", "100 bits")]
    2626        //[TaskPane("Rounds", "How many bits shall be generated?", null, 1, false, DisplayLevel.Beginner, ControlType.TextBox)]
    27         [TaskPane("Number of rounds", "How many bits shall be generated? Note: This only applies if no boolean clock is used.", null, 2, false, DisplayLevel.Beginner, ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
     27        [TaskPane("Number of rounds", "How many bits shall be generated? Note: This only applies if no external clock is used.", null, 2, false, DisplayLevel.Beginner, ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
    2828        public int Rounds
    2929        {
     
    3636        }
    3737
    38         string polynomial;
     38        /*string polynomial;
    3939        [TaskPane("Polynomial", "Define the feedback polynomial either in a textual or a numeric way. For example x^5 +x^2 + 1 which is equal to 10010", null, 0, false, DisplayLevel.Beginner, ControlType.TextBox)]
    4040        public string Polynomial
     
    6262                HasChanges = true;
    6363            }
    64         }
     64        }*/
    6565
    6666        private bool noQuickwatch = false;
    67         [ContextMenu("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for better performance.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Display Quickwatch?" })]
    68         [TaskPane("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for better performance.", null, 3, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     67        [ContextMenu("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for a better performance.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Display Quickwatch?" })]
     68        [TaskPane("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for a better performance.", null, 3, false, DisplayLevel.Experienced, ControlType.CheckBox, "", null)]
    6969        public bool NoQuickwatch
    7070        {
     
    7979
    8080        private int clockingBit = 0;
    81         [TaskPane("Clocking bit number", "Which bit shall be generated as an additional output? For example as an clocking bit.", "Additional Output Bit", 0, false, DisplayLevel.Beginner, ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
     81        [TaskPane("Additional output bit #", "Which bit shall be generated as an additional output? For example as an clocking bit.", "Additional Output Bit", 0, false, DisplayLevel.Beginner, ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
    8282        public int ClockingBit
    8383        {
     
    9191        }
    9292
    93         private bool useClockingBit = false;
    94         [ContextMenu("Use clocking bit", "With this checkbox enabled, the clocking bit will be generated.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Use clocking bit?" })]
    95         [TaskPane("Use clocking bit", "With this checkbox enabled, clocking bit will be generated.", "Additional Output Bit", 1, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
    96         public bool UseClockingBit
     93        private bool useAdditionalOutputBit = false;
     94        [ContextMenu("Generate add. output bit", "With this checkbox enabled, the additional output bit will be generated.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Generate additional output bit?" })]
     95        [TaskPane("Generate add. output bit", "With this checkbox enabled, the additional output bit will be generated.", "Additional Output Bit", 1, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     96        public bool UseAdditionalOutputBit
    9797        {
    98             get { return this.useClockingBit; }
     98            get { return this.useAdditionalOutputBit; }
    9999            set
    100100            {
    101                 this.useClockingBit = (bool)value;
     101                this.useAdditionalOutputBit = (bool)value;
    102102                OnPropertyChanged("UseClockingBit");
    103103                HasChanges = true;
     
    106106
    107107        private bool useBoolClock = false;
    108         [ContextMenu("Use BoolClock", "With this checkbox enabled, BoolClock will be used.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Use Boolean clock?" })]
    109         [TaskPane("Use BoolClock", "With this checkbox enabled, BoolClock will be used.", "Clock Properties", 0, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     108        [ContextMenu("Use external clock", "With this checkbox enabled, an external clock will be used.", 0, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Use external clock?" })]
     109        [TaskPane("Use external clock", "With this checkbox enabled, an external clock will be used (i.e. the CLK-Plugin)", "Clock Properties", 0, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
    110110        public bool UseBoolClock
    111111        {
     
    133133        }
    134134
    135         private bool createDirtyOutputOnFalseClock = false;
     135        /*private bool createDirtyOutputOnFalseClock = false;
    136136        [ContextMenu("Create dirty output on false clock", "With this checkbox enabled, an the output is the dirty (-1) if the clock is set to false.", 2, DisplayLevel.Experienced, ContextMenuControlType.CheckBox, null, new string[] { "Create dirty output?" })]
    137137        [TaskPane("Create dirty output on false clock", "With this checkbox enabled, an the output is the dirty (-1) if the clock is set to false.", "Clock Properties", 2, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     
    145145                HasChanges = true;
    146146            }
    147         }
     147        }*/
    148148
    149149        public bool HasChanges
Note: See TracChangeset for help on using the changeset viewer.