Changeset 304


Ignore:
Timestamp:
May 6, 2009, 6:27:10 PM (13 years ago)
Author:
Sören Rinne
Message:
  • added some AND plugin icons
  • added Berlekamp-Massey algorithm plugin (computes polynomial C(D) for a LFSR with minimal length L from given output stream of an unknown LFSR)
  • modified BoolComparator, CLK, LFSR, Majority and XORBinary plugins
Location:
trunk/CrypPlugins
Files:
15 added
11 edited

Legend:

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

    r296 r304  
    206206using System.Linq;
    207207using System.Text;
     208
    208209using Cryptool.PluginBase;
    209 using Cryptool.PluginBase.Cryptography;
    210 
    211210using System.IO;
    212211using System.ComponentModel;
     212using Cryptool.PluginBase.Cryptography;
    213213using Cryptool.PluginBase.IO;
    214214using System.Windows.Controls;
     215using Cryptool.PluginBase.Miscellaneous;
     216using System.Security.Cryptography;
    215217// for [MethodImpl(MethodImplOptions.Synchronized)]
    216218using System.Runtime.CompilerServices;
     
    219221{
    220222    [Author("Soeren Rinne", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for System Security", "http://www.trust.rub.de/")]
    221     [PluginInfo(false, "ANDBinary", "Simple Binary AND", "ANDBinary/DetailedDescription/Description.xaml", "ANDBinary/Images/icon.png", "ANDBinary/Images/icon.png", "ANDBinary/Images/icon.png")]
     223    [PluginInfo(false, "ANDBinary", "Simple Binary AND", "ANDBinary/DetailedDescription/Description.xaml", "ANDBinary/Images/icon.png", "ANDBinary/Images/iconInput1Inverted.png", "ANDBinary/Images/iconInput2Inverted.png", "ANDBinary/Images/iconOutputInverted.png")]
    222224    public class ANDBinary : IThroughput
    223225    {
     
    263265        {
    264266            [MethodImpl(MethodImplOptions.Synchronized)]
    265             get { return this.inputOne; }
     267            get
     268            {
     269                /*if (settings.InvertInputOne)
     270                {
     271                    return (!inputOne);
     272                }
     273                else*/ return this.inputOne;
     274            }
     275
    266276            [MethodImpl(MethodImplOptions.Synchronized)]
    267277            set
     
    307317
    308318        public void Initialize()
     319        {           
     320        }
     321
     322        public void Dispose()
     323        {
     324        }
     325
     326        public UserControl Presentation
     327        {
     328            get { return null; }
     329        }
     330
     331        public UserControl QuickWatchPresentation
     332        {
     333            get { return null; }
     334        }
     335
     336        public void Stop()
     337        {
     338        }
     339
     340        public void PostExecution()
     341        {
     342        }
     343
     344        public void PreExecution()
    309345        {
    310346            // set input flags according to settings
     
    313349            if (settings.FlagInputTwo) inputTwoFlag = 1;
    314350            else inputTwoFlag = -1;
    315         }
    316 
    317         public void Dispose()
    318         {
    319         }
    320 
    321         public UserControl Presentation
    322         {
    323             get { return null; }
    324         }
    325 
    326         public UserControl QuickWatchPresentation
    327         {
    328             get { return null; }
    329         }
    330 
    331         public void Stop()
    332         {
    333         }
    334 
    335         public void PostExecution()
    336         {
    337         }
    338 
    339         public void PreExecution()
    340         {
     351
     352            // set icon according to settings
     353            if (settings.InvertInputOne) StatusChanged((int)ANDImage.Input1Inverted);
     354            else StatusChanged((int)ANDImage.Default);
    341355        }
    342356
     
    346360
    347361        public event PropertyChangedEventHandler PropertyChanged;
     362
     363        public event StatusChangedEventHandler OnPluginStatusChanged;
    348364
    349365        public void OnPropertyChanged(string name)
     
    371387        #region IPlugin Members
    372388
    373 #pragma warning disable 67
    374         public event StatusChangedEventHandler OnPluginStatusChanged;
     389//#pragma warning disable 67
    375390        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    376391        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    377 #pragma warning restore
     392//#pragma warning restore
    378393
    379394        public void Execute()
     
    384399                inputOneFlag = -1;
    385400                inputTwoFlag = -1;
    386 
    387                 output = inputOne & inputTwo;
     401                if (settings.InvertInputOne)
     402                {
     403                    output = !inputOne & inputTwo;
     404                } else output = inputOne & inputTwo;
    388405                OnPropertyChanged("Output");
    389406            }
     
    394411        }
    395412
     413        private void StatusChanged(int imageIndex)
     414        {
     415            EventsHelper.StatusChanged(OnPluginStatusChanged, this, new StatusEventArgs(StatusChangedMode.ImageUpdate, imageIndex));
     416        }
     417
    396418        #endregion
    397419    }
     420
     421    #region Image
     422
     423    enum ANDImage
     424    {
     425        Default,
     426        Input1Inverted,
     427        Input2Inverted,
     428        OutputInverted
     429    }
     430
     431    #endregion
    398432}
  • trunk/CrypPlugins/ANDBinary/ANDBinary.csproj

    r292 r304  
    7979    </Resource>
    8080  </ItemGroup>
     81  <ItemGroup>
     82    <Resource Include="Images\iconInput1Inverted.png" />
     83    <Resource Include="Images\iconInput2Inverted.png" />
     84    <Resource Include="Images\iconOutputInverted.png" />
     85  </ItemGroup>
    8186  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    8287  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  • trunk/CrypPlugins/ANDBinary/ANDBinarySettings.cs

    r296 r304  
    270270        }
    271271
     272        bool invertInputOne;
     273        [ContextMenu("Invert I1", " yes / no ", 0, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Invert Input 1.")]
     274        [TaskPaneAttribute("Invert I1", " yes / no ", "", 0, false, DisplayLevel.Beginner, ControlType.CheckBox, null)]
     275        public bool InvertInputOne
     276        {
     277            get { return this.invertInputOne; }
     278            set
     279            {
     280                this.invertInputOne = value;
     281                OnPropertyChanged("InvertInputOne");
     282                HasChanges = true;
     283            }
     284
     285        }
     286
    272287        #endregion
    273288
  • trunk/CrypPlugins/BoolComparator/BoolComparator.cs

    r296 r304  
    308308        public void Initialize()
    309309        {
     310        }
     311
     312        public void Dispose()
     313        {
     314        }
     315
     316        public UserControl Presentation
     317        {
     318            get { return null; }
     319        }
     320
     321        public UserControl QuickWatchPresentation
     322        {
     323            get { return null; }
     324        }
     325
     326        public void Stop()
     327        {
     328        }
     329
     330        public void PostExecution()
     331        {
     332        }
     333
     334        public void PreExecution()
     335        {
    310336            // set input flags according to settings
    311337            if (settings.FlagInputOne) inputOneFlag = 1;
     
    315341        }
    316342
    317         public void Dispose()
    318         {
    319         }
    320 
    321         public UserControl Presentation
    322         {
    323             get { return null; }
    324         }
    325 
    326         public UserControl QuickWatchPresentation
    327         {
    328             get { return null; }
    329         }
    330 
    331         public void Stop()
    332         {
    333         }
    334 
    335         public void PostExecution()
    336         {
    337         }
    338 
    339         public void PreExecution()
    340         {
    341         }
    342 
    343343        #endregion
    344344
  • trunk/CrypPlugins/CLK/CLK.cs

    r289 r304  
    2121    # region private variables
    2222    private bool output;
     23    private bool eventInput;
    2324    private int timeout = 2000;
    2425    private int rounds = 10;
     
    2728
    2829    public int myRounds;
     30    public DateTime startTime;
    2931
    3032    public CLK()
     
    7476    }
    7577
     78    [PropertyInfo(Direction.Input, "EventInput", "EventInput", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     79    public bool EventInput
     80    {
     81        get { return eventInput; }
     82        set
     83        {
     84            eventInput = value;
     85            OnPropertyChanged("EventInput");
     86        }
     87    }
     88
    7689
    7790    # endregion public interface
     
    104117        myRounds = settings.Rounds;
    105118        GuiLogMessage("myRounds: " + myRounds.ToString(), NotificationLevel.Info);
     119
     120        startTime = DateTime.Now;
    106121    }
    107122
    108123    public void Execute()
    109124    {
    110         if (settings.CLKTimeout <= 499)
    111         {
    112             GuiLogMessage("Are you trying to generate bulk output? Please do not use CLK plugin for this purpose. Try setting the number of rounds in the corresponding plugin settings.", NotificationLevel.Warning);
     125        if (settings.UseEvent)
     126        {
     127            if (myRounds != 0)
     128            {
     129                OnPropertyChanged("Output");
     130                myRounds--;
     131            }
     132            else
     133            {
     134                // stop counter
     135                DateTime stopTime = DateTime.Now;
     136                // compute overall time
     137                TimeSpan duration = stopTime - startTime;
     138                GuiLogMessage("Overall time used: " + duration, NotificationLevel.Info);
     139            }
    113140        }
    114141        else
    115142        {
    116             process(settings.CLKTimeout);
    117             //change picture
    118             if (settings.SetClockToTrue) StatusChanged((int)CLKImage.True);
    119             else StatusChanged((int)CLKImage.False);
    120         }
    121        
     143            if (settings.CLKTimeout <= 499)
     144            {
     145                GuiLogMessage("Are you trying to generate bulk output? Please do not use CLK plugin for this purpose. Try setting the number of rounds in the corresponding plugin settings.", NotificationLevel.Warning);
     146            }
     147            else
     148            {
     149                process(settings.CLKTimeout);
     150                //change picture
     151                if (settings.SetClockToTrue) StatusChanged((int)CLKImage.True);
     152                else StatusChanged((int)CLKImage.False);
     153            }
     154        }
    122155    }
    123156
  • trunk/CrypPlugins/CLK/CLKSettings.cs

    r288 r304  
    1414    private bool hasChanges = false;
    1515    private bool setClockToTrue = true;
     16    private bool useEvent = false;
    1617    private int clkTimeout = 2000;
    1718    # endregion private variables
     
    6970    }
    7071
     72    [ContextMenu("Use input event instead of clock", " yes / no ", 0, DisplayLevel.Beginner, ContextMenuControlType.CheckBox, null, "Use input event instead of clock")]
     73    [TaskPaneAttribute("Use input event instead of clock", " yes / no ", "", 0, true, DisplayLevel.Beginner, ControlType.CheckBox, null)]
     74    public bool UseEvent
     75    {
     76        get { return this.useEvent; }
     77        set
     78        {
     79            this.useEvent = value;
     80            OnPropertyChanged("UseEvent");
     81            HasChanges = true;
     82        }
     83
     84    }
     85
    7186    private int rounds = 10; //how many bits will be generated
    7287    //[ContextMenu("Rounds", "How many bits shall be generated?", 1, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, new int[] { 10, 50, 100 }, "10 bits", "50 bits", "100 bits")]
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r296 r304  
    2525{
    2626    [Author("Soeren Rinne", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for System Security", "http://www.trust.rub.de/")]
    27     [PluginInfo(false, "LFSR", "Linear Feedback Shift Register (simple version)", "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
     
    3636        private CryptoolStream inputClock;
    3737        private CryptoolStream outputStream;
     38        private String outputString;
    3839        private bool outputBool;
    3940        private bool inputClockBool;
     
    5253        public String tapSequencebuffer = "1";
    5354        public Char outputbuffer = '0';
    54         public bool lastInputPropertyClock = false;
     55        public bool lastInputPropertyWasBoolClock = false;
     56
     57        // for process()
     58        public char[] tapSequenceCharArray = null;
     59        public int seedBits = 1; // dummy value for compiler
     60        public int actualRounds = 1; // dummy value for compiler
     61        public Boolean myClock = true;
     62        public char[] seedCharArray = null;
     63        public int clocking;
     64        public string outputStringBuffer = null;
    5565
    5666        #endregion
     
    8494                inputTapSequence = value;
    8595                OnPropertyChanged("InputTapSequence");
    86                 lastInputPropertyClock = false;
     96                lastInputPropertyWasBoolClock = false;
    8797            }
    8898        }
     
    98108                inputSeed = value;
    99109                OnPropertyChanged("InputSeed");
    100                 lastInputPropertyClock = false;
     110                lastInputPropertyWasBoolClock = false;
    101111            }
    102112        }
     
    136146                inputClockBool = value;
    137147                OnPropertyChanged("InputClockBool");
    138                 lastInputPropertyClock = true;
    139             }
    140         }
    141 
    142         [PropertyInfo(Direction.Output, "Output stream", "LFSR Stream Output. Use this fpr bulk output.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     148                lastInputPropertyWasBoolClock = true;
     149            }
     150        }
     151
     152        [PropertyInfo(Direction.Output, "Output stream", "LFSR Stream Output. Use this for bulk output.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    143153        public CryptoolStream OutputStream
    144154        {
     
    164174        }
    165175
     176        [PropertyInfo(Direction.Output, "String Output", "Produces the output bits as a string with length==rounds. Use this output without a clock input.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     177        public String OutputString
     178        {
     179            get { return outputString; }
     180            set
     181            {
     182                outputString = value.ToString();
     183                OnPropertyChanged("OutputString");
     184            }
     185        }
     186
    166187        [PropertyInfo(Direction.Output, "Boolean Output", "LFSR Boolean Output. Use this output together with a clock input.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    167188        public bool OutputBool
     
    171192            {
    172193                outputBool = (bool)value;
    173                 OnPropertyChanged("OutputBool");
     194                //OnPropertyChanged("OutputBool");
    174195            }
    175196        }
     
    185206            }
    186207        }
     208        /*
     209        private bool controllerOutput;
     210        [ControllerProperty(Direction.Output, "Controller Output", "", DisplayLevel.Beginner)]
     211        public object ControllerOutput
     212        {
     213            get { return controllerOutput; }
     214            set { controllerOutput = (bool)value; }
     215        }*/
    187216
    188217        public void Dispose()
     
    192221                stop = false;
    193222                outputStream = null;
     223                outputString = null;
     224                outputStringBuffer = null;
    194225                inputClock = null;
    195226                inputTapSequence = null;
     
    310341            if (gotX) strPolyBinary += 1;
    311342            else strPolyBinary += 0;
    312             strPolyBinary += 1;
     343
     344            strPolyBinary = new String(ReverseOrder(strPolyBinary.ToCharArray()));
     345            //GuiLogMessage("strPolyBinary is: " + strPolyBinary, NotificationLevel.Info);
    313346
    314347            return strPolyBinary;
     
    355388            for (int i = 0; i < tapSequence.Length; i++)
    356389            {
    357                 power = (i - tapSequence.Length + 1) * -1 % tapSequence.Length;
     390                power = (i - tapSequence.Length + 1) * -1 % tapSequence.Length + 1;
    358391                if (tempTapSequence[i] == '1')
    359392                {
    360393                    if (power == 1) polynomial += "x + ";
    361394                    else if (power != 0) polynomial += "x^" + power + " + ";
    362                     else polynomial += "1";
    363                 }
    364             }
     395                    //else polynomial += "1";
     396                }
     397            }
     398            // add last "+1"
     399            polynomial += "1";
    365400
    366401            return  polynomial;
     
    380415            // if so, check if boolean clock should be used
    381416            // if not, do not process LFSR
    382             if (lastInputPropertyClock)
     417            if (lastInputPropertyWasBoolClock)
    383418            {
    384419                if (!settings.UseBoolClock) return;
     420            }
     421                // if last event wasn't from the clock but clock shall be
     422                // the only event to start from, do not go on
     423            else
     424            {
     425                if (settings.UseBoolClock) return;
    385426            }
    386427            // process LFSR
     
    388429            try
    389430            {
    390                 checkForInputTapSequence();
    391                 checkForInputSeed();
    392 
    393                 if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
    394                 {
    395                     GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
    396                     if (!settings.UseBoolClock) inputClock.Close();
    397                     return;
    398                 }
    399 
    400                 if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
    401                 {
    402                     GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
    403                     if (!settings.UseBoolClock) inputClock.Close();
    404                     return;
    405                 }
    406 
    407                 // read tapSequence
    408                 tapSequencebuffer = inputTapSequence;
    409                
    410                 // check if tapSequence is binary
    411                 bool tapSeqisBool = true;
    412                 foreach (char character in tapSequencebuffer)
    413                 {
    414                     if (character != '0' && character != '1')
    415                     {
    416                         tapSeqisBool = false;
    417                         //return;
    418                     }
    419                 }
    420 
    421                 // if tapSequence is not binary, await polynomial
    422                 if (!tapSeqisBool)
    423                 {
    424                     GuiLogMessage("TapSequence is not binary. Awaiting polynomial.", NotificationLevel.Info);
    425                     if (IsPolynomial(tapSequencebuffer))
    426                     {
    427                         GuiLogMessage(tapSequencebuffer + " is a valid polynomial.", NotificationLevel.Info);
    428                         tapSequencebuffer = MakeBinary(tapSequencebuffer);
    429                         GuiLogMessage("Polynomial in binary form: " + tapSequencebuffer, NotificationLevel.Info);
    430 
    431                         // check if polynomial has false length
    432                         if (tapSequencebuffer.Length != inputSeed.Length)
    433                         {
    434                             /*// check if its too long
    435                             if (inputSeed.Length - tapSequencebuffer.Length < 0)
    436                             {
    437                                 GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " is TOO LONG (" + tapSequencebuffer.Length + " Bits) for your seed. Aborting now.", NotificationLevel.Error);
    438                                 if (!settings.UseBoolClock) inputClock.Close();
    439                                 return;
    440                             }
    441                             // seems to be too short, so fill it with zeros at the beginning
    442                             else
    443                             {
    444                                 for (int j = inputSeed.Length - tapSequencebuffer.Length; j > 0; j--)
    445                                 {
    446                                     tapSequencebuffer = "0" + tapSequencebuffer;
    447                                 }
    448                             }*/
    449                             GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " has to be the same length (" + tapSequencebuffer.Length + " Bits) as your seed (" + inputSeed.Length + " Bits). Aborting now.", NotificationLevel.Error);
    450                             if (!settings.UseBoolClock) inputClock.Close();
    451                             return;
    452                         }
    453 
    454                         //GuiLogMessage("Polynomial after length fitting: " + tapSequencebuffer, NotificationLevel.Info);
    455                     }
    456                     else
    457                     {
    458                         GuiLogMessage("ERROR - " + tapSequencebuffer + " is NOT a valid polynomial. Aborting now.", NotificationLevel.Error);
    459                         //Console.WriteLine("\n{0} is NOT a valid polynomial.", tapSequencebuffer);
    460                         if (!settings.UseBoolClock) inputClock.Close();
    461                         return;
    462                     }
    463                 }
    464 
    465                 // convert tapSequence into char array
    466                 char[] tapSequenceCharArray = ReverseOrder(tapSequencebuffer.ToCharArray());
    467 
    468                 if (tapSequencebuffer.Length != inputSeed.Length)
    469                 {
    470                     // stop, because seed and tapSequence must have same length
    471                     GuiLogMessage("ERROR - Seed and tapSequence must have same length. Aborting now.", NotificationLevel.Error);
    472                     if (!settings.UseBoolClock) inputClock.Close();
    473                     return;
    474                 }
    475 
    476                 int tapSequenceBits = inputTapSequence.Length;
    477                 int seedBits = inputSeed.Length;
    478 
    479                 GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug);
    480                 GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug);
    481 
    482                 //read seed only one time until stop of chain
    483                 if (newSeed)
    484                 {
    485                     seedbuffer = inputSeed;
    486                     newSeed = false;
    487                 }
    488 
    489                 //check if last and first tap is 1, otherwise stop
    490                 if (tapSequenceCharArray[tapSequenceCharArray.Length - 1] == '0')
    491                 {
    492                     GuiLogMessage("ERROR - Last tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
    493                     return;
    494                 }
    495                 else if (tapSequenceCharArray[0] == '0')
    496                 {
    497                     GuiLogMessage("ERROR - First tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
    498                     return;
    499                 }
    500 
    501                 // convert seed into char array
    502                 char[] seedCharArray = seedbuffer.ToCharArray();
    503 
    504                 // check if seed is binary
    505                 foreach (char character in seedCharArray)
    506                 {
    507                     if (character != '0' && character != '1')
    508                     {
    509                         GuiLogMessage("ERROR 0 - Seed has to be binary. Aborting now. Character is: " + character, NotificationLevel.Error);
    510                         return;
    511                     }
    512                 }
    513                 int clocking;
    514                 if (settings.UseClockingBit) clocking = settings.ClockingBit; else clocking = -1;
    515                 lFSRPresentation.DrawLFSR(seedCharArray, tapSequenceCharArray, clocking);
     431                /*char[] tapSequenceCharArray = null;
     432                int seedBits = 1; // dummy value for compiler
     433                int actualRounds = 1; // dummy value for compiler
     434                Boolean myClock = true;
     435                char[] seedCharArray = null;
    516436
    517437                // open output stream
     
    519439                listCryptoolStreamsOut.Add(outputStream);
    520440                outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
    521 
     441                */
     442
     443                // make all this stuff only one time at the beginning of our chainrun
     444                if (newSeed)
     445                {
     446                    checkForInputTapSequence();
     447                    checkForInputSeed();
     448
     449                    if (inputSeed == null || (inputSeed != null && inputSeed.Length == 0))
     450                    {
     451                        GuiLogMessage("No Seed given. Aborting now.", NotificationLevel.Error);
     452                        if (!settings.UseBoolClock) inputClock.Close();
     453                        return;
     454                    }
     455
     456                    if (inputTapSequence == null || (inputTapSequence != null && inputTapSequence.Length == 0))
     457                    {
     458                        GuiLogMessage("No TapSequence given. Aborting now.", NotificationLevel.Error);
     459                        if (!settings.UseBoolClock) inputClock.Close();
     460                        return;
     461                    }
     462
     463                    // read tapSequence
     464                    tapSequencebuffer = inputTapSequence;
     465
     466                    // check if tapSequence is binary
     467                    bool tapSeqisBool = true;
     468                    foreach (char character in tapSequencebuffer)
     469                    {
     470                        if (character != '0' && character != '1')
     471                        {
     472                            tapSeqisBool = false;
     473                            //return;
     474                        }
     475                    }
     476
     477                    // if tapSequence is not binary, await polynomial
     478                    if (!tapSeqisBool)
     479                    {
     480                        GuiLogMessage("TapSequence is not binary. Awaiting polynomial.", NotificationLevel.Info);
     481                        if (IsPolynomial(tapSequencebuffer))
     482                        {
     483                            GuiLogMessage(tapSequencebuffer + " is a valid polynomial.", NotificationLevel.Info);
     484                            tapSequencebuffer = MakeBinary(tapSequencebuffer);
     485                            GuiLogMessage("Polynomial in binary form: " + tapSequencebuffer, NotificationLevel.Info);
     486
     487                            // check if polynomial has false length
     488                            if (tapSequencebuffer.Length != inputSeed.Length)
     489                            {
     490                                /*// check if its too long
     491                                if (inputSeed.Length - tapSequencebuffer.Length < 0)
     492                                {
     493                                    GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " is TOO LONG (" + tapSequencebuffer.Length + " Bits) for your seed. Aborting now.", NotificationLevel.Error);
     494                                    if (!settings.UseBoolClock) inputClock.Close();
     495                                    return;
     496                                }
     497                                // seems to be too short, so fill it with zeros at the beginning
     498                                else
     499                                {
     500                                    for (int j = inputSeed.Length - tapSequencebuffer.Length; j > 0; j--)
     501                                    {
     502                                        tapSequencebuffer = "0" + tapSequencebuffer;
     503                                    }
     504                                }*/
     505                                GuiLogMessage("ERROR - Your polynomial " + tapSequencebuffer + " has to be the same length (" + tapSequencebuffer.Length + " Bits) as your seed (" + inputSeed.Length + " Bits). Aborting now.", NotificationLevel.Error);
     506                                if (!settings.UseBoolClock) inputClock.Close();
     507                                return;
     508                            }
     509
     510                            //GuiLogMessage("Polynomial after length fitting: " + tapSequencebuffer, NotificationLevel.Info);
     511                        }
     512                        else
     513                        {
     514                            GuiLogMessage("ERROR - " + tapSequencebuffer + " is NOT a valid polynomial. Aborting now.", NotificationLevel.Error);
     515                            //Console.WriteLine("\n{0} is NOT a valid polynomial.", tapSequencebuffer);
     516                            if (!settings.UseBoolClock) inputClock.Close();
     517                            return;
     518                        }
     519                    }
     520
     521                    // convert tapSequence into char array
     522                    //tapSequenceCharArray = ReverseOrder(tapSequencebuffer.ToCharArray());
     523                    tapSequenceCharArray = tapSequencebuffer.ToCharArray();
     524
     525                    if (tapSequencebuffer.Length != inputSeed.Length)
     526                    {
     527                        // stop, because seed and tapSequence must have same length
     528                        GuiLogMessage("ERROR - Seed and tapSequence must have same length. Aborting now.", NotificationLevel.Error);
     529                        if (!settings.UseBoolClock) inputClock.Close();
     530                        return;
     531                    }
     532
     533                    int tapSequenceBits = inputTapSequence.Length;
     534                    seedBits = inputSeed.Length;
     535
     536                    GuiLogMessage("inputTapSequence length [bits]: " + tapSequenceBits.ToString(), NotificationLevel.Debug);
     537                    GuiLogMessage("inputSeed length [bits]: " + seedBits.ToString(), NotificationLevel.Debug);
     538
     539                    //read seed only one time until stop of chain
     540                    seedbuffer = inputSeed;
     541                    newSeed = false;
     542
     543                    //check if last tap is 1, otherwise stop
     544                    if (tapSequenceCharArray[tapSequenceCharArray.Length - 1] == '0')
     545                    {
     546                        GuiLogMessage("ERROR - Last tap of tapSequence must be 1. Aborting now.", NotificationLevel.Error);
     547                        return;
     548                    }
     549
     550                    // convert seed into char array
     551                    seedCharArray = seedbuffer.ToCharArray();
     552
     553                    // check if seed is binary
     554                    foreach (char character in seedCharArray)
     555                    {
     556                        if (character != '0' && character != '1')
     557                        {
     558                            GuiLogMessage("ERROR 0 - Seed has to be binary. Aborting now. Character is: " + character, NotificationLevel.Error);
     559                            return;
     560                        }
     561                    }
     562                    if (settings.UseClockingBit) clocking = settings.ClockingBit; else clocking = -1;
     563
     564                    /*// check which clock to use
     565                    if (settings.UseBoolClock)
     566                    {
     567                        myClock = inputClockBool;
     568                    }
     569                    else if (!settings.UseBoolClock)
     570                    {
     571                        // read stream clock
     572                        checkForInputClock();
     573                        inputClock.OpenWrite("LFSR Restart");
     574                        String stringClock = inputClock.ReadByte().ToString();
     575                        inputClock.Position = 0;
     576                        if (String.Equals(stringClock, "49")) myClock = true; else myClock = false;
     577                        //inputClock.Close();
     578                    }*/
     579
     580                    // check if Rounds are given
     581                    int defaultRounds = 1;
     582
     583                    // check if Rounds in settings are given and use them only if no bool clock is selected
     584                    if (!settings.UseBoolClock)
     585                    {
     586                        if (settings.Rounds == 0) actualRounds = defaultRounds; else actualRounds = settings.Rounds;
     587                    }
     588                    else actualRounds = 1;
     589                }
    522590               
    523 
     591                // Here we go!
    524592                // check which clock to use
    525                 Boolean myClock = true;
    526 
    527593                if (settings.UseBoolClock)
    528594                {
     
    531597                else if (!settings.UseBoolClock)
    532598                {
    533                     // read stream clocks
     599                    // read stream clock
    534600                    checkForInputClock();
    535601                    inputClock.OpenWrite("LFSR Restart");
     
    540606                }
    541607
    542                 // check if Rounds are given
    543                 int defaultRounds = 1;
    544                 int actualRounds;
    545 
    546                 // check if Rounds in settings are given and use them only if no bool clock is selected
    547                 if (!settings.UseBoolClock)
    548                 {
    549                     if (settings.Rounds == 0) actualRounds = defaultRounds; else actualRounds = settings.Rounds;
    550                 }
    551                 else actualRounds = 1;
    552                
    553                 // Here we go!
     608                // draw LFSR Quickwatch
     609                if (!settings.NoQuickwatch)
     610                {
     611                    lFSRPresentation.DrawLFSR(seedCharArray, tapSequenceCharArray, clocking);
     612                }
     613
     614                // open output stream
     615                outputStream = new CryptoolStream();
     616                listCryptoolStreamsOut.Add(outputStream);
     617                outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     618
    554619                //GuiLogMessage("Action is: Now!", NotificationLevel.Debug);
    555620                DateTime startTime = DateTime.Now;
     
    558623                // compute LFSR //////////////////////////////////////
    559624                //////////////////////////////////////////////////////
    560                 GuiLogMessage("Starting computation", NotificationLevel.Info);
     625                GuiLogMessage("Starting computation", NotificationLevel.Debug);
    561626               
    562627                int i = 0;
     
    574639                        //GuiLogMessage("OutputBool is: " + outputBool.ToString(), NotificationLevel.Info);
    575640
    576                         // write last bit to output buffer, stream and bool
     641                        // write last bit to output buffer, output stream buffer, stream and bool
    577642                        outputbuffer = seedCharArray[seedBits - 1];
    578643                        outputStream.Write((Byte)outputbuffer);
     644                        if (!settings.UseBoolClock) outputStringBuffer += seedCharArray[seedBits - 1];
    579645
    580646                        // update outputs
     
    587653                        // compute new bit
    588654                        bool firstDone = false;
    589                         for (int j = 1; j < seedBits; j++)
     655                        for (int j = 0; j < seedBits; j++)
    590656                        {
    591657                            // check if tapSequence is 1
     
    612678                        {
    613679                            seedCharArray[j] = seedCharArray[j - 1];
     680                            //GuiLogMessage("seedCharArray[" + j + "] is: " + seedCharArray[j], NotificationLevel.Info);
    614681                        }
    615682                        seedCharArray[0] = newBit;
    616683
    617684                        //update quickwatch presentation
    618                         lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, outputBit, BuildPolynomialFromBinary(tapSequenceCharArray));
     685                        if (!settings.NoQuickwatch)
     686                        {
     687                            lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, outputBit, BuildPolynomialFromBinary(tapSequenceCharArray));
     688                        }
    619689
    620690                        // write current "seed" back to seedbuffer
     
    631701                        {
    632702                            /////////
    633                             // but nevertheless fire an output event with old value
     703                            // but nevertheless fire an output event with dirty value / old value
    634704                            /////////
    635                             // make bool output
    636                             if (seedCharArray[seedBits - 1] == '0') outputBool = false;
    637                             else outputBool = true;
    638                             //GuiLogMessage("OutputBool is: " + outputBool.ToString(), NotificationLevel.Info);
    639 
    640                             // write last bit to output buffer, stream and bool
    641                             outputbuffer = seedCharArray[seedBits - 1];
    642                             outputStream.Write((Byte)outputbuffer);
    643 
    644                             OnPropertyChanged("OutputBool");
    645                             OnPropertyChanged("OutputStream");
    646 
    647                             //update quickwatch presentation
    648                             lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, seedCharArray[seedBits - 1], BuildPolynomialFromBinary(tapSequenceCharArray));
     705                            if (settings.CreateDirtyOutputOnFalseClock)
     706                            {
     707                                outputBool = false;
     708                                outputbuffer = '2';
     709                                outputStream.Write((Byte)outputbuffer);
     710
     711                                OnPropertyChanged("OutputBool");
     712                                OnPropertyChanged("OutputStream");
     713
     714                                //update quickwatch presentation
     715                                if (!settings.NoQuickwatch)
     716                                {
     717                                    lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, '2', BuildPolynomialFromBinary(tapSequenceCharArray));
     718                                }
     719                            }
     720                            else
     721                            {
     722                                // make bool output
     723                                if (seedCharArray[seedBits - 1] == '0') outputBool = false;
     724                                else outputBool = true;
     725                                //GuiLogMessage("OutputBool is: " + outputBool.ToString(), NotificationLevel.Info);
     726
     727                                // write last bit to output buffer, stream and bool
     728                                outputbuffer = seedCharArray[seedBits - 1];
     729                                outputStream.Write((Byte)outputbuffer);
     730
     731                                OnPropertyChanged("OutputBool");
     732                                OnPropertyChanged("OutputStream");
     733
     734                                //update quickwatch presentation
     735                                if (!settings.NoQuickwatch)
     736                                {
     737                                    lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, seedCharArray[seedBits - 1], BuildPolynomialFromBinary(tapSequenceCharArray));
     738                                }
     739                            }
    649740                            /////////
    650741                        }
     
    652743                        {
    653744                            // update quickwatch with current state but without any output bit
    654                             lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, ' ', BuildPolynomialFromBinary(tapSequenceCharArray));
     745                            if (!settings.NoQuickwatch)
     746                            {
     747                                lFSRPresentation.FillBoxes(seedCharArray, tapSequenceCharArray, ' ', BuildPolynomialFromBinary(tapSequenceCharArray));
     748                            }
    655749                        }
    656750
     
    675769                if (!stop)
    676770                {
    677                     GuiLogMessage("Complete!", NotificationLevel.Info);
    678 
    679                     GuiLogMessage("Time used: " + duration, NotificationLevel.Info);
     771                    // finally write output string if no bool-clock was used
     772                    if (!settings.UseBoolClock)
     773                    {
     774                        outputString = outputStringBuffer;
     775                        OnPropertyChanged("OutputString");
     776                    }
     777
     778                    GuiLogMessage("Complete!", NotificationLevel.Debug);
     779
     780                    GuiLogMessage("Time used: " + duration, NotificationLevel.Debug);
    680781                    outputStream.Close();
    681782                    if (!settings.UseBoolClock) inputClock.Close();
     
    687788                    outputStream.Close();
    688789                    if (!settings.UseBoolClock) inputClock.Close();
    689                     GuiLogMessage("Aborted!", NotificationLevel.Info);
     790                    GuiLogMessage("Aborted!", NotificationLevel.Debug);
    690791                }
    691792            }
  • trunk/CrypPlugins/LFSR/LFSRPresentation.xaml.cs

    r296 r304  
    198198                    myTextBoxes[i].BorderBrush = Brushes.Black;
    199199                    //if (i % 2 != 0) myTextBoxes[i].Background = Brushes.Lavender;
    200                     if (i != 0)
    201                     {
     200                    //if (i != 0)
     201                    //{
    202202                        if (tapSequence[i] == '1') myTextBoxes[i].Background = Brushes.DodgerBlue;
    203                     }
     203                    //}
    204204                    if (clockingBit == i) myTextBoxes[i].Background = Brushes.Orange;
    205205
     
    258258                    }
    259259                }
    260                 // disable last and first XOR
    261                 myGrids[0].Visibility = Visibility.Hidden;
     260                // disable /*last*/ and first XOR
     261                //myGrids[0].Visibility = Visibility.Hidden;
    262262                myGrids[state.Length - 1].Visibility = Visibility.Hidden;
    263263
  • trunk/CrypPlugins/LFSR/LFSRSettings.cs

    r296 r304  
    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 boolean clock is used.", null, 0, false, DisplayLevel.Beginner, ControlType.NumericUpDown, ValidationType.RangeInteger, 0, int.MaxValue)]
    2828        public int Rounds
    2929        {
     
    3232                this.rounds = value;
    3333                OnPropertyChanged("Rounds");
     34                HasChanges = true;
     35            }
     36        }
     37
     38        private bool noQuickwatch = false;
     39        [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?" })]
     40        [TaskPane("Do not display Quickwatch", "With this checkbox enabled, no quickwatch will be generated for better performance.", null, 1, false, DisplayLevel.Beginner, ControlType.CheckBox, "", null)]
     41        public bool NoQuickwatch
     42        {
     43            get { return this.noQuickwatch; }
     44            set
     45            {
     46                this.noQuickwatch = (bool)value;
     47                OnPropertyChanged("NoQuickwatch");
    3448                HasChanges = true;
    3549            }
     
    91105        }
    92106
     107        private bool createDirtyOutputOnFalseClock = false;
     108        [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?" })]
     109        [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)]
     110        public bool CreateDirtyOutputOnFalseClock
     111        {
     112            get { return this.createDirtyOutputOnFalseClock; }
     113            set
     114            {
     115                this.createDirtyOutputOnFalseClock = (bool)value;
     116                OnPropertyChanged("CreateDirtyOutputOnFalseClock");
     117                HasChanges = true;
     118            }
     119        }
     120
    93121        public bool HasChanges
    94122        {
  • trunk/CrypPlugins/Majority/Majority.cs

    r296 r304  
    219219{
    220220    [Author("Soeren Rinne", "soeren.rinne@cryptool.de", "Ruhr-Universitaet Bochum, Chair for System Security", "http://www.trust.rub.de/")]
    221     [PluginInfo(true, "Majority", "Simple Binary XOR", "Majority/DetailedDescription/Description.xaml", "Majority/Images/icon.png", "Majority/Images/icon.png", "Majority/Images/icon.png")]
     221    [PluginInfo(true, "Majority", "Computes the majority of three boolean inputs\n1, if sum(1)>=sum(0); 0 else", "Majority/DetailedDescription/Description.xaml", "Majority/Images/icon.png", "Majority/Images/icon.png", "Majority/Images/icon.png")]
    222222    public class Majority : IThroughput
    223223    {
     
    325325        public void Initialize()
    326326        {
    327             // set both inputs dirty
     327        }
     328
     329        public void Dispose()
     330        {
     331        }
     332
     333        public UserControl Presentation
     334        {
     335            get { return null; }
     336        }
     337
     338        public UserControl QuickWatchPresentation
     339        {
     340            get { return null; }
     341        }
     342
     343        public void Stop()
     344        {
     345        }
     346
     347        public void PostExecution()
     348        {
     349        }
     350
     351        public void PreExecution()
     352        {
     353            // set all inputs dirty
    328354            inputOneFlag = -1;
    329355            inputTwoFlag = -1;
    330         }
    331 
    332         public void Dispose()
    333         {
    334         }
    335 
    336         public UserControl Presentation
    337         {
    338             get { return null; }
    339         }
    340 
    341         public UserControl QuickWatchPresentation
    342         {
    343             get { return null; }
    344         }
    345 
    346         public void Stop()
    347         {
    348         }
    349 
    350         public void PostExecution()
    351         {
    352         }
    353 
    354         public void PreExecution()
    355         {
     356            inputThreeFlag = -1;
    356357        }
    357358
  • trunk/CrypPlugins/XORBinary/XORBinary.cs

    r296 r304  
    288288            }
    289289        }
     290        /*
     291        private bool controllerInput;
     292        [ControllerProperty(Direction.Input, "Controller Input", "", DisplayLevel.Beginner)]
     293        public object ControllerInput
     294        {
     295            get { return controllerInput; }
     296            set { controllerInput = (bool)value; }
     297        }*/
    290298
    291299        [PropertyInfo(Direction.Output, "XOR Output", "Output after XORing input one and two. Only fires up, if both inputs are fresh.", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     
    307315
    308316        public void Initialize()
     317        {
     318        }
     319
     320        public void Dispose()
     321        {
     322        }
     323
     324        public UserControl Presentation
     325        {
     326            get { return null; }
     327        }
     328
     329        public UserControl QuickWatchPresentation
     330        {
     331            get { return null; }
     332        }
     333
     334        public void Stop()
     335        {
     336        }
     337
     338        public void PostExecution()
     339        {
     340        }
     341
     342        public void PreExecution()
    309343        {
    310344            // set input flags according to settings
     
    315349        }
    316350
    317         public void Dispose()
    318         {
    319         }
    320 
    321         public UserControl Presentation
    322         {
    323             get { return null; }
    324         }
    325 
    326         public UserControl QuickWatchPresentation
    327         {
    328             get { return null; }
    329         }
    330 
    331         public void Stop()
    332         {
    333         }
    334 
    335         public void PostExecution()
    336         {
    337         }
    338 
    339         public void PreExecution()
    340         {
    341         }
    342 
    343351        #endregion
    344352
Note: See TracChangeset for help on using the changeset viewer.