Changeset 726


Ignore:
Timestamp:
Oct 14, 2009, 8:30:14 PM (12 years ago)
Author:
kopal
Message:

cleaned up the source code of SDES (added comments header for each method, sorted methods and so on)

Location:
trunk/CrypPlugins/SDES
Files:
2 edited

Legend:

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

    r717 r726  
    2929namespace Cryptool.Plugins.Cryptography.Encryption
    3030{
     31    /// <summary>
     32    /// This plugin encrypts / decrypts texts with the simplified DES alogrithm (SDES)
     33    /// It can be used as plugin in a normal encryption/decryption chanin or be
     34    /// used by the KeySearcher to do bruteforcing
     35    /// </summary>
    3136    [Author("Nils Kopal", "nils.kopal@cryptool.de", "Uni Duisburg", "http://www.uni-duisburg-essen.de")]
    3237    [PluginInfo(false, "SDES", "Simplified Data Encryption Standard", "SDES/DetailedDescription/Description.xaml", "SDES/icon.png", "SDES/Images/encrypt.png", "SDES/Images/decrypt.png")]
     
    3540    {
    3641        #region Private variables
     42
    3743        private SDESSettings settings;
    3844        private CryptoolStream inputStream;
     
    4248        private byte[] inputIV;       
    4349        private bool stop = false;
     50        private SDESControl controlSlave;
     51
    4452        #endregion
    4553
     54        #region events
     55
     56        public event PropertyChangedEventHandler PropertyChanged;
     57        public event StatusChangedEventHandler OnPluginStatusChanged;
     58        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
     59        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
     60
     61        #endregion
     62
     63        #region public
     64
     65        /// <summary>
     66        /// Tells you wether input changed or not
     67        /// </summary>
    4668        public bool InputChanged
    4769        { get; set; }
    4870
     71        /// <summary>
     72        /// Constructs a new SDES
     73        /// </summary>
    4974        public SDES()
    5075        {
     
    5479        }
    5580
     81        /// <summary>       
     82        /// The status of the plugin changes
     83        /// </summary>
     84        /// <param name="sender"></param>
     85        /// <param name="args"></param>
    5686        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
    5787        {
     
    5989        }
    6090
     91        /// <summary>
     92        /// Sets/Gets the settings of this plugin
     93        /// </summary>
    6194        public ISettings Settings
    6295        {
     
    6598        }
    6699   
     100        /// <summary>
     101        /// Is this Plugin in Status stop?
     102        /// </summary>
     103        /// <returns></returns>
    67104        public bool getStop()
    68105        {
     
    70107        }
    71108
     109        /// <summary>
     110        /// Gets/Sets the input of the SDES plugin (the text which should be encrypted/decrypted)
     111        /// </summary>
    72112        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    73113        public CryptoolStream InputStream
     
    104144        }
    105145
     146        /// <summary>
     147        /// Gets/Sets the output of the SDES plugin (the text which is encrypted/decrypted)
     148        /// </summary>
    106149        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    107150        public CryptoolStream OutputStream
     
    138181        }
    139182
    140         [PropertyInfo(Direction.InputData, "Key", "Must be 10 bytes (only 1 or 0 allowed).", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
     183        /// <summary>
     184        /// Gets/Sets the key which should be used.Must be 10 bytes  (only 1 or 0 allowed).
     185        /// </summary>
     186        [PropertyInfo(Direction.InputData, "Key", "Must be 8 bytes (only 1 or 0 allowed).", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    141187        public byte[] InputKey
    142188        {
     
    150196        }
    151197
     198        /// <summary>
     199        /// Gets/Sets the Initialization Vector which should be used.Must be 10 bytes  (only 1 or 0 allowed).
     200        /// </summary>
    152201        [PropertyInfo(Direction.InputData, "IV", "IV to be used in chaining modes, must be 10 bytes (only 1 or 0 allowed).", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
    153202        public byte[] InputIV
     
    160209            }
    161210        }
    162        
     211
     212        /// <summary>
     213        /// Start encrypting
     214        /// </summary>
     215        public void Encrypt()
     216        {
     217            //Encrypt Stream
     218            process(0);
     219        }
     220
     221        /// <summary>
     222        /// Start decrypting
     223        /// </summary>
     224        public void Decrypt()
     225        {
     226            //Decrypt Stream
     227            process(1);
     228        }
     229
     230        /// <summary>
     231        /// Called by the environment to start this plugin
     232        /// </summary>
     233        public void Execute()
     234        {
     235            process(settings.Action);
     236        }
     237
     238
     239        /// <summary>
     240        /// Get the Presentation of this plugin
     241        /// </summary>
     242        public UserControl Presentation
     243        {
     244            get { return null; }
     245        }
     246
     247        /// <summary>
     248        /// Get the QuickWatchPresentation of this plugin
     249        /// </summary>
     250        public UserControl QuickWatchPresentation
     251        {
     252            get { return null; }
     253        }
     254
     255        /// <summary>
     256        /// Called by the environment to do initialization
     257        /// </summary>
     258        public void Initialize()
     259        {
     260        }
     261
     262        /// <summary>
     263        /// Called by the envorinment if this plugin is unloaded
     264        /// closes all streams
     265        /// </summary>
     266        public void Dispose()
     267        {
     268            try
     269            {
     270                this.stop = false;
     271                inputKey = null;
     272                inputIV = null;
     273
     274                foreach (CryptoolStream stream in listCryptoolStreamsOut)
     275                {
     276                    stream.Close();
     277                }
     278                listCryptoolStreamsOut.Clear();
     279
     280                if (controlSlave != null)
     281                    controlSlave.Dispose();
     282
     283            }
     284            catch (Exception ex)
     285            {
     286                GuiLogMessage(ex.Message, NotificationLevel.Error);
     287            }
     288        }
     289
     290        /// <summary>
     291        /// Called by the environment of this plugin to stop it
     292        /// </summary>
     293        public void Stop()
     294        {
     295            this.stop = true;
     296        }
     297
     298        /// <summary>
     299        /// Called by the environment of this plugin after execution
     300        /// </summary>
     301        public void PostExecution()
     302        {
     303            Dispose();
     304        }
     305
     306        /// <summary>
     307        /// Called by the environment of this plugin before execution
     308        /// </summary>
     309        public void PreExecution()
     310        {
     311            Dispose();
     312        }
     313
     314        /// <summary>
     315        /// A property of this plugin changed
     316        /// </summary>
     317        /// <param name="name">propertyname</param>
     318        public void OnPropertyChanged(string name)
     319        {
     320            if (PropertyChanged != null)
     321            {
     322                PropertyChanged(this, new PropertyChangedEventArgs(name));
     323            }
     324        }
     325
     326        /// <summary>
     327        /// Logs a message into the messages of crypttool
     328        /// </summary>
     329        /// <param name="message">message</param>
     330        /// <param name="logLevel">logLevel</param>
     331        public void GuiLogMessage(string message, NotificationLevel logLevel)
     332        {
     333            if (OnGuiLogNotificationOccured != null)
     334            {
     335                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, logLevel));
     336            }
     337        }
     338
     339        /// <summary>
     340        /// Sets the current progess of this plugin
     341        /// </summary>
     342        /// <param name="value">value</param>
     343        /// <param name="max">max</param>
     344        public void ProgressChanged(double value, double max)
     345        {
     346            if (OnPluginProgressChanged != null)
     347            {
     348                OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
     349            }
     350        }
     351
     352        /// <summary>
     353        /// Called by the environment of this plugin if it is set to pause
     354        /// </summary>
     355        public void Pause()
     356        {
     357
     358        }
     359
     360        /// <summary>
     361        /// Sets/Gets the ControlSlave of this plugin
     362        /// </summary>
     363        [PropertyInfo(Direction.ControlSlave, "SDES Slave", "Direct access to SDES.", "", DisplayLevel.Beginner)]
     364        public IControlEncryption ControlSlave
     365        {
     366            get
     367            {
     368                if (controlSlave == null)
     369                    controlSlave = new SDESControl(this);
     370                return controlSlave;
     371            }
     372        }
     373
     374        #endregion public
     375
     376        #region private
     377
     378        /// <summary>
     379        /// This method checks if the input stream is valid. If it is not valid it sets it to a dummy stream
     380        /// (this funcionality is stolen from DES plugin ;) )
     381        /// </summary>
    163382        private void checkForInputStream()
    164383        {
     
    174393        }
    175394
    176         /**
    177          * Checks if the Input key is not null and has length 10 and only contains 1s and 0s
    178          * and if Input IV is not null and has length 8 and only contains 1s and 0s
    179          *
    180          * returns true if ok
    181          *
    182          **/
     395        /// <summary>
     396        /// Checks if the Input key is not null and has length 10 and only contains 1s and 0s
     397        /// and if Input IV is not null and has length 8 and only contains 1s and 0s
     398        /// </summary>
     399        /// <returns>true if ok</returns>
    183400        private bool areKeyAndIVValid()
    184401        {
     
    216433        }
    217434
    218         public void Execute()
    219         {
    220             process(settings.Action);
    221         }
    222 
    223         //Encrypt/Decrypt Stream
     435        /// <summary>
     436        /// Starts the encryption/decryption process with SDES
     437        /// </summary>
     438        /// <param name="action">0 = encrypt, 1 = decrypt</param>
    224439        private void process(int action)
    225440        {
     
    315530        }
    316531
    317         public void Encrypt()
    318         {
    319             //Encrypt Stream
    320             process(0);
    321         }
    322 
    323         public void Decrypt()
    324         {
    325             //Decrypt Stream
    326             process(1);
    327         }
    328 
    329         #region IPlugin Member
    330 
    331         public UserControl Presentation
    332         {
    333             get { return null; }
    334         }
    335 
    336         public UserControl QuickWatchPresentation
    337         {
    338           get { return null; }
    339         }
    340 
    341         public void Initialize()
    342         {
    343         }
    344 
    345         public void Dispose()
    346         {
    347             try
    348             {
    349                 this.stop = false;
    350                 inputKey = null;
    351                 inputIV = null;
    352 
    353                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    354                 {
    355                     stream.Close();
    356                 }
    357                 listCryptoolStreamsOut.Clear();
    358 
    359                 if (controlSlave != null)
    360                     controlSlave.Dispose();
    361                
    362             }
    363             catch (Exception ex)
    364             {
    365                 GuiLogMessage(ex.Message, NotificationLevel.Error);
    366             }
    367         }
    368 
    369         public void Stop()
    370         {
    371             this.stop = true;
    372         }
    373 
    374         public void PostExecution()
    375         {
    376             Dispose();
    377         }
    378 
    379         public void PreExecution()
    380         {
    381             Dispose();
    382         }
    383 
    384532        #endregion
    385533
    386         private SDESControl controlSlave;
    387         [PropertyInfo(Direction.ControlSlave, "SDES Slave", "Direct access to SDES.", "", DisplayLevel.Beginner)]
    388         public IControlEncryption ControlSlave
    389         {
    390             get
    391             {
    392                 if (controlSlave == null)
    393                     controlSlave = new SDESControl(this);
    394                 return controlSlave;
    395             }
    396         } 
    397 
    398         #region INotifyPropertyChanged Members
    399 
    400         public event PropertyChangedEventHandler PropertyChanged;
    401 
    402         public void OnPropertyChanged(string name)
    403         {
    404             if (PropertyChanged != null)
    405             {
    406                 PropertyChanged(this, new PropertyChangedEventArgs(name));
    407             }
    408         }
    409 
    410         #endregion
    411 
    412         #region IPlugin Members
    413 
    414         public event StatusChangedEventHandler OnPluginStatusChanged;
    415 
    416         public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
    417         public void GuiLogMessage(string message, NotificationLevel logLevel)
    418         {
    419           if (OnGuiLogNotificationOccured != null)
    420           {
    421             OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, logLevel));
    422           }
    423         }
    424 
    425         public event PluginProgressChangedEventHandler OnPluginProgressChanged;
    426         public void ProgressChanged(double value, double max)
    427         {
    428           if (OnPluginProgressChanged != null)
    429           {
    430             OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
    431           }
    432         }
    433 
    434         public void Pause()
    435         {
    436          
    437         }
    438 
    439         #endregion
    440 
    441     }
    442 
     534    }//end SDES
     535
     536    /// <summary>
     537    /// This Class is for controlling the SDES with a "brute forcer" like KeySearcher
     538    /// </summary>
    443539    public class SDESControl : IControlEncryption
    444540    {
    445         public static int counter=0;
    446 
    447         public event KeyPatternChanged keyPatternChanged; //not used, because we only have one key length
    448         public event IControlStatusChangedEventHandler OnStatusChanged;
     541        #region private
    449542        private SDES plugin;
    450543        private CryptoolStream input;
    451544        private List<CryptoolStream> listCryptoolStreams = new List<CryptoolStream>();
    452 
     545        #endregion
     546
     547        #region events
     548        public event KeyPatternChanged keyPatternChanged; //not used, because we only have one key length
     549        public event IControlStatusChangedEventHandler OnStatusChanged;
     550        #endregion
     551
     552        #region public
     553
     554        /// <summary>
     555        /// Constructs a new SDESControl
     556        /// </summary>
     557        /// <param name="Plugin"></param>
    453558        public SDESControl(SDES Plugin)
    454559        {
    455             this.plugin = Plugin;     
    456             counter++;
    457             plugin.GuiLogMessage("Counter:" + counter,NotificationLevel.Info);
    458         }
    459 
     560            this.plugin = Plugin;                 
     561        }
     562
     563        /// <summary>
     564        /// Called by SDES if its status changes
     565        /// </summary>
    460566        public void onStatusChanged()
    461567        {
     
    463569                OnStatusChanged(this, true);
    464570        }
    465 
    466         #region IControlEncryption Members
    467 
     571     
     572        /// <summary>
     573        /// Called by a Master to start encryption
     574        /// </summary>
     575        /// <param name="key">key</param>
     576        /// <param name="blocksize">blocksize</param>
     577        /// <returns>encrypted text</returns>
    468578        public byte[] Encrypt(byte[] key, int blocksize)
    469579        {
     
    472582        }
    473583
     584        /// <summary>
     585        /// Called by a Master to start decryption
     586        /// </summary>
     587        /// <param name="key">key</param>
     588        /// <param name="blocksize">blocksize</param>
     589        /// <returns>decrypted text</returns>
    474590        public byte[] Decrypt(byte[] key, int blocksize)
    475591        {
     
    478594        }
    479595
     596        /// <summary>
     597        /// Get the key pattern of the SDES algorithm
     598        /// </summary>
     599        /// <returns>[01][01][01][01][01][01][01][01][01][01]</returns>
    480600        public string getKeyPattern()
    481601        {
     
    483603        }
    484604
     605        /// <summary>
     606        /// Makes a byte Array out of a String
     607        /// example
     608        /// "10101" -> '1','0','1','0','1'
     609        ///
     610        /// A 0 is interpreted as '0'
     611        /// any other character as '1'
     612        /// </summary>
     613        /// <param name="key"></param>
     614        /// <returns></returns>
    485615        public byte[] getKeyFromString(string key)
    486616        {
     
    495625        }
    496626
     627        /// <summary>
     628        /// Called by the SDES plugin if it is disposing
     629        /// closes all privaet streams
     630        /// </summary>
     631        public void Dispose()
     632        {
     633            foreach (CryptoolStream cs in listCryptoolStreams)
     634                cs.Close();
     635        }
     636
     637        #endregion
     638
     639        #region private
     640
     641        /// <summary>
     642        /// Called by itself to start encryption/decryption
     643        /// </summary>
     644        /// <param name="key">key</param>
     645        /// <param name="blocksize">blocksize</param>
     646        /// <returns>encrypted/decrypted text</returns>
    497647        private byte[] execute(byte[] key, int blocksize)
    498648        {
     
    532682        }
    533683
    534         public void Dispose()
    535         {
    536             foreach (CryptoolStream cs in listCryptoolStreams)
    537                 cs.Close();
    538         }
    539 
    540684        #endregion
    541685    }
    542 
    543     /**
    544      *
    545      * Encapsulates the SDES algorithm
    546      *
    547      **/
     686       
     687    /// <summary>
     688    /// Encapsulates the SDES algorithm
     689    /// </summary>
    548690    public class SDES_algorithm
    549691    {
     
    555697        }
    556698
    557         /**
    558          * Encrypt-function
    559          *
    560          * Encrypts the input plaintext with the given key
    561          *
    562          * @param plaintext as byte array of size 8
    563          * @param key as byte array of size 10
    564          * @return ciphertext as byte array of size 8
    565          */
     699        /// <summary>
     700        /// Encrypt-function       
     701        /// Encrypts the input plaintext with the given key
     702        /// </summary>
     703        /// <param name="plaintext">plaintext as byte array of size 8</param>
     704        /// <param name="key">key as byte array of size 10</param>
     705        /// <returns>ciphertext as byte array of size 8</returns>
    566706        public byte[] encrypt(byte[] plaintext, byte[] key)
    567707        {
     
    582722        }//end encrypt
    583723
    584         /**
    585          * Decrypt-function
    586          *
    587          * Decrypts the input ciphertext with the given key
    588          *
    589          * @param plaintext as byte array of size 8
    590          * @param key as byte array of size 10
    591          * @return plaintext as byte array of size 8
    592          */
     724        /// <summary>
     725        /// Decrypt-function
     726        /// Decrypts the input ciphertext with the given key
     727        /// </summary>
     728        /// <param name="ciphertext">ciphertext as byte array of size 8</param>
     729        /// <param name="key"> key as byte array of size 10</param>
     730        /// <returns>plaintext as byte array of size 8</returns>
    593731        public byte[] decrypt(byte[] ciphertext, byte[] key)
    594732        {
     
    609747        }//end decrypt
    610748
    611         /**
    612          * p10-function
    613          * Permutates the input bytes array of "10 bits" to another by
    614          * the following rule:
    615          *
    616          * src    dest
    617          * 1   -> 3
    618          * 2   -> 5
    619          * 3   -> 2
    620          * 4   -> 7
    621          * 5   -> 4
    622          * 6   -> 10
    623          * 7   -> 1
    624          * 8   -> 9
    625          * 9   -> 8
    626          * 10  -> 6
    627          *
    628          * @param byte array of size 10
    629          * @return byte array of size 10
    630          */
     749        ///<summary>
     750        ///p10-function
     751        ///Permutates the input bytes array of "10 bits" to another by
     752        ///the following rule:
     753        ///
     754        ///src    dest
     755        ///1   -> 3
     756        ///2   -> 5
     757        ///3   -> 2
     758        ///4   -> 7
     759        ///5   -> 4
     760        ///6   -> 10
     761        ///7   -> 1
     762        ///8   -> 9
     763        ///9   -> 8
     764        ///10  -> 6
     765        ///</summary>
     766        ///<param name="bits">byte array of size 10</param>
     767        ///<returns>byte array of size 10</returns>
     768        ///
    631769        private byte[] p10(byte[] bits)
    632770        {
     
    650788        }//end p10
    651789
    652         /**
    653          * p8-function
    654          * Permutates the input bytes array of "8 bits" to another by
    655          * the following rule:
    656          *
    657          * src    dest
    658          * 1   -> 6
    659          * 2   -> 3
    660          * 3   -> 7
    661          * 4   -> 4
    662          * 5   -> 8
    663          * 6   -> 5
    664          * 7   -> 10
    665          * 8   -> 9
    666          *
    667          * @param byte array of size 10
    668          * @return byte array of size 8
    669          */
     790        ///<summary>
     791        ///p8-function
     792        ///Permutates the input bytes array of "8 bits" to another by
     793        ///the following rule:
     794        ///
     795        ///src    dest
     796        ///1   -> 6
     797        ///2   -> 3
     798        ///3   -> 7
     799        ///4   -> 4
     800        ///5   -> 8
     801        ///6   -> 5
     802        ///7   -> 10
     803        ///8   -> 9
     804        ///</summary>
     805        ///<param name="bits">byte array of size 10</param>
     806        ///<returns>byte array of size 8</returns>
    670807        private byte[] p8(byte[] bits)
    671808        {
     
    687824        }//end p8
    688825
    689         /**
    690          * ip-function (initial permutation)
    691          * Permutates the input array of "8 bits" to another by
    692          * the following rule:
    693          *
    694          * src    dest
    695          * 1   -> 2
    696          * 2   -> 6
    697          * 3   -> 3
    698          * 4   -> 1
    699          * 5   -> 4
    700          * 6   -> 8
    701          * 7   -> 5
    702          * 8   -> 7
    703          *
    704          * @param byte array of size 8
    705          * @return byte array of size 8
    706          */
     826        ///<summary>
     827        ///ip-function (initial permutation)
     828        ///Permutates the input array of "8 bits" to another by
     829        ///the following rule:
     830        ///
     831        ///src    dest
     832        ///1   -> 2
     833        ///2   -> 6
     834        ///3   -> 3
     835        ///4   -> 1
     836        ///5   -> 4
     837        ///6   -> 8
     838        ///7   -> 5
     839        ///8   -> 7
     840        ///</summary>
     841        ///<param name="bits">byte array of size 8</param>
     842        ///<returns>byte array of size 8</returns>
    707843        private byte[] ip(byte[] bits)
    708844        {
     
    724860        }//end ip
    725861
    726         /**
    727          * ip^-1-function (initial permutation inverse)
    728          * Permutates the input array of "8 bits" to another by
    729          * the following rule:
    730          *
    731          * src    dest
    732          * 1   -> 4
    733          * 2   -> 1
    734          * 3   -> 3
    735          * 4   -> 5
    736          * 5   -> 7
    737          * 6   -> 2
    738          * 7   -> 8
    739          * 8   -> 6
    740          *
    741          * @param byte array of size 8
    742          * @return byte array of size 8
    743          */
     862        ///<summary>
     863        ///ip^-1-function (initial permutation inverse)
     864        ///Permutates the input array of "8 bits" to another by
     865        ///the following rule:
     866        ///
     867        ///src    dest
     868        ///1   -> 4
     869        ///2   -> 1
     870        ///3   -> 3
     871        ///4   -> 5
     872        ///5   -> 7
     873        ///6   -> 2
     874        ///7   -> 8
     875        ///8   -> 6
     876        ///</summary>
     877        ///<param name="bits">byte array of size 8</param>
     878        ///<returns>byte array of size 8</returns>
    744879        private byte[] ip_inverse(byte[] bits)
    745880        {
     
    761896        }//end ip_inverse
    762897
    763         /**
    764          * fk-function
    765          *
    766          * combines the following functions:
    767          *
    768          * right is the right part of the input array
    769          * left is the left part of the input array
    770          *
    771          * (right | left) := (inputarray))
    772          * ret := exclusive_or(left,F(right,key)) + right)
    773          *
    774          * @param byte array of size 8
    775          * @return byte array of size 8
    776          */
     898        ///<summary>
     899        ///fk-function
     900        ///
     901        ///combines the following functions:
     902        ///
     903        ///right is the right part of the input array
     904        ///left is the left part of the input array
     905        ///
     906        ///(right | left) := (inputarray))
     907        ///ret := exclusive_or(left,F(right,key)) + right)
     908        ///</summary>
     909        ///<param name="bits">byte array of size 8</param>
     910        ///<param name="key">byte array of size 8</param>
     911        ///<returns>byte array of size 8</returns>
    777912        private byte[] fk(byte[] bits, byte[] key)
    778913        {
     
    791926        }//end fk
    792927
    793         /**
    794          * ls-1 function
    795          *
    796          * @param byte array of size 10
    797          * @return byte array of size 10
    798          */
     928        ///<summary>
     929        ///ls-1 function
     930        ///</summary>
     931        ///<param name="bits">byte array of size 10</param>
     932        ///<returns>byte array of size 10</returns>
    799933        private byte[] ls_1(byte[] bits)
    800934        {
     
    818952        }//end ls_1
    819953
    820         /**
    821          * switch-function
    822          *
    823          * switches the left side and the right side of the 8 bit array
    824          * (left|right) -> (right|left)
    825          *
    826          * @param byte array of size 8
    827          * @return byte array of size 8
    828          */
     954        ///<summary>
     955        ///switch-function
     956        ///
     957        ///switches the left side and the right side of the 8 bit array
     958        ///(left|right) -> (right|left)
     959        ///</summary>
     960        ///<param name="bits">byte array of size 8</param>
     961        ///<returns>byte array of size 8</returns>
    829962        private byte[] sw(byte[] bits)
    830963        {
     
    838971        }//end sw
    839972
    840         /**
    841          * F-function
    842          *
    843          * combines both s-boxes and permutates the return value with p4
    844          * p4( s0(exclusive_or(ep(number),key) | s1(exclusive_or(ep(number),key) )
    845          *
    846          * @param byte array of size 8
    847          * @param key of size 8
    848          * @return byte array of size 8
    849          */
     973        ///<summary>
     974        ///F-function
     975        ///
     976        ///combines both s-boxes and permutates the return value with p4
     977        ///p4( s0(exclusive_or(ep(number),key) | s1(exclusive_or(ep(number),key) )
     978        ///</summary>
     979        ///<param name="bits">byte array of size 8</param>
     980        ///<param name="bits">key of size 8</param>
     981        ///<returns>byte array of size 8</returns>
    850982        private byte[] F(byte[] bits, byte[] key)
    851983        {
     
    8691001        }//end F
    8701002
    871         /**
    872          * p4-function
    873          * Permutates the input array of "4 bits" to another by
    874          * the following rule:
    875          *
    876          * src    dest
    877          * 1   -> 2
    878          * 2   -> 4
    879          * 3   -> 3
    880          * 4   -> 1
    881          * 
    882          * @param byte array of size 4
    883          * @return byte array of size 4
    884          */
     1003        ///<summary>
     1004        ///p4-function
     1005        ///Permutates the input array of "4 bits" to another by
     1006        ///the following rule:
     1007        ///
     1008        ///src    dest
     1009        ///1   -> 2
     1010        ///2   -> 4
     1011        ///3   -> 3
     1012        ///4   -> 1
     1013        ///</summary>
     1014        ///<param name="bits">byte array of size 4</param>
     1015        ///<returns>byte array of size 4</returns>
    8851016        private byte[] p4(byte[] bits)
    8861017        {
     
    8961027        }//end p4
    8971028
    898         /**
    899          * ep-function
    900          * Permutates the input array of "4 bits" to another array of "8 bits" by
    901          * the following rule:
    902          *
    903          * src    dest
    904          * 1   -> 4
    905          * 2   -> 1
    906          * 3   -> 2
    907          * 4   -> 3
    908          * 5   -> 2
    909          * 6   -> 3
    910          * 7   -> 4
    911          * 8   -> 1
    912          *
    913          * @param byte array of size 4
    914          * @return byte array of size 8
    915          */
     1029        ///<summary>
     1030        ///ep-function
     1031        ///Permutates the input array of "4 bits" to another array of "8 bits" by
     1032        ///the following rule:
     1033        ///
     1034        ///src    dest
     1035        ///1   -> 4
     1036        ///2   -> 1
     1037        ///3   -> 2
     1038        ///4   -> 3
     1039        ///5   -> 2
     1040        ///6   -> 3
     1041        ///7   -> 4
     1042        ///8   -> 1
     1043        ///</summary>
     1044         ///<param name="bits">byte array of size 4</param>
     1045        ///<returns>byte array of size 8</returns>
    9161046        private byte[] ep(byte[] bits)
    9171047        {
     
    9301060        }
    9311061
    932         /**
    933          * SBox-0
    934          *
    935          * S0 =  1 0 3 2
    936          *       3 2 1 0
    937          *       0 2 1 3   
    938          *       3 1 3 2           
    939          *
    940          * @param byte array of size 4
    941          * @return byte array of size 2
    942          */
     1062        ///<summary>
     1063        ///SBox-0
     1064        ///
     1065        ///S0 =  1 0 3 2
     1066        ///      3 2 1 0
     1067        ///      0 2 1 3   
     1068        ///      3 1 3 2           
     1069        ///</summary>
     1070        ///<param name="bits">byte array of size 4</param>
     1071        ///<returns>byte array of size 2</returns>
    9431072        private byte[] sbox_0(byte[] bits)
    9441073        {
     
    9631092
    9641093
    965         /**
    966          * SBox-1
    967          *
    968          * S1 =  0 1 2 3
    969          *       2 0 1 3
    970          *       3 0 1 0
    971          *       2 1 0 3
    972          *
    973          * @param byte array of size 4
    974          * @return byte array of size 8
    975          */
     1094        ///<summary>
     1095        ///SBox-1
     1096        ///
     1097        ///S1 =  0 1 2 3
     1098        ///      2 0 1 3
     1099        ///      3 0 1 0
     1100        ///      2 1 0 3
     1101        ///</summary>
     1102        ///<param name="bits">byte array of size 4</param>
     1103        ///<returns>byte array of size 2</returns>
    9761104        private byte[] sbox_1(byte[] bits)
    9771105        {
     
    9971125    }
    9981126
    999     /**
    1000     *
    1001     * Encapsulates some necessary functions
    1002     *
    1003     **/
     1127    ///<summary>
     1128    ///Encapsulates some necessary functions
     1129    ///</summary>
    10041130    public class Tools
    10051131    {
    10061132
    1007         /**
    1008          * Converts an byte array to a String
    1009          *
    1010          * @param byte array of size n
    1011          * @return String
    1012          */
     1133        ///<summary>
     1134        ///Converts an byte array to a String
     1135        ///</summary>
     1136        ///<param name="bits">byte array of size n</param>
     1137        ///<returns>String</returns>
    10131138        public static String byteArray2String(byte[] bits)
    10141139        {
     
    10231148        }//end byteArray2String
    10241149
    1025         /**
    1026          * Converts the given byte array to a printable String
    1027          *
    1028          * example {72, 101, 108, 108, 111} -> "Hello"
    1029          *
    1030          * @param bits
    1031          * @return String
    1032          */
     1150        ///<summary>
     1151        ///Converts the given byte array to a printable String
     1152        ///
     1153        ///example {72, 101, 108, 108, 111} -> "Hello"
     1154        ///</summary>
     1155        ///<param name="bits">byte array of size n</param>
     1156        ///<returns>String</returns>
    10331157        public static String byteArray2PrintableString(byte[] bits)
    10341158        {
     
    10431167        }// byteArray2PrintableString
    10441168
    1045         /**
    1046          * equals-function
    1047          *
    1048          * returns true if both integer arrays are equal
    1049          *
    1050          * @param byte array of size n
    1051          * @param byte array of size n
    1052          * @return boolean
    1053          */
     1169        ///<summary>
     1170        ///equals-function
     1171        ///
     1172        ///returns true if both integer arrays are equal
     1173        ///</summary>
     1174        ///<param name="a">byte array of size n</param>
     1175        ///<param name="b">byte array of size n</param>
     1176        ///<returns>bool</returns>
    10541177        public static bool byteArrays_Equals(byte[] a, byte[] b)
    10551178        {
     
    10671190        }//end byteArrays_Equals       
    10681191
    1069         /**
    1070          * converts an Byte to an byte array of (0,1)
    1071          *
    1072          * 100 -> {1,1,0,0,1,0,0}
    1073          *
    1074          * @param b
    1075          * @return
    1076          */
     1192        ///<summary>
     1193        ///converts an Byte to an byte array of (0,1)
     1194        ///
     1195        ///100 -> {1,1,0,0,1,0,0}
     1196        ///</summary>
     1197        ///<param name="byt">byte array of size n</param>
     1198        ///<returns>byte array</returns>
    10771199        public static byte[] byteToByteArray(byte byt)
    10781200        {
     
    10921214        }//end byteTointArray
    10931215
    1094         /**
    1095          * converts an byte array of (0,1) to an byte
    1096          *
    1097          * {1,1,0,0,1,0,0} -> 100
    1098          * @param intarray
    1099          * @return
    1100          */
     1216        ///<summary>
     1217        ///converts an byte array of (0,1) to an byte
     1218        ///
     1219        ///{1,1,0,0,1,0,0} -> 100
     1220        ///</summary>
     1221        ///<param name="bytearray">byte array of size n</param>
     1222        ///<returns>byte</returns>
    11011223        public static byte byteArrayToByte(byte[] bytearray)
    11021224        {
     
    11171239        }//end byteArrayToInteger
    11181240
    1119         /**
    1120          * Exclusiv-OR function
    1121          *
    1122          * Does a exlusiv-or on two byte arrays
    1123          *
    1124          * example {1,0,1} XOR {1,0,0} -> {0,0,1}
    1125          *
    1126          * @param byte array of size n
    1127          * @param byte array of size n
    1128          * @return byte array of size n
    1129          */
     1241        ///<summary>
     1242        ///Exclusiv-OR function
     1243        ///
     1244        ///Does a exlusiv-or on two byte arrays
     1245        ///
     1246        ///example {1,0,1} XOR {1,0,0} -> {0,0,1}
     1247        ///</summary>
     1248        ///<param name="bitsA">byte array of size n</param>
     1249        ///<param name="bitsB">byte array of size n</param>
     1250        ///<returns>byte array of size n</returns>
    11301251        public static byte[] exclusive_or(byte[] bitsA, byte[] bitsB)
    11311252        {
     
    11531274        }//end exclusive_or
    11541275
    1155         /**
    1156          * converts string to an byte array
    1157          *
    1158          * example "Hello" -> {72, 101, 108, 108, 111}
    1159          *
    1160          * @param s
    1161          * @return
    1162          */
     1276        ///<summary>
     1277        ///converts string to an byte array
     1278        ///
     1279        ///example "Hello" -> {72, 101, 108, 108, 111}
     1280        ///</summary>
     1281        ///<param name="s">String</param>
     1282        ///<returns>byte array</returns>
    11631283        public static byte[] stringToByteArray(String s)
    11641284        {
     
    11741294        }// end stringToByteArray
    11751295
    1176         /**
    1177          * converts a binary string to an byte array
    1178          *
    1179          * example "10010" -> {1, 0, 0, 1, 0}
    1180          *
    1181          * @param s
    1182          * @return
    1183          */
     1296        ///<summary>
     1297        ///converts a binary string to an byte array
     1298        ///
     1299        ///example "10010" -> {1, 0, 0, 1, 0}
     1300        ///</summary>
     1301        ///<param name="s">String</param>
     1302        ///<returns>byte array</returns>
    11841303        public static byte[] stringToBinaryByteArray(String s)
    11851304        {
     
    12071326    }
    12081327
    1209     /**
    1210     *
    1211     * Encapsulates the CipherBlockChaining algorithm
    1212     *
    1213     **/
     1328    ///<summary>
     1329    ///Encapsulates the CipherBlockChaining algorithm
     1330    ///</summary>
    12141331    public class CipherBlockChaining
    12151332    {
     
    12181335        private SDES_algorithm mAlgorithm;
    12191336
     1337        /// <summary>
     1338        /// Constructs a CipherBlockChaining for SDES
     1339        /// </summary>
     1340        /// <param name="sdes">plugin</param>
    12201341        public CipherBlockChaining(SDES sdes)
    12211342        {
     
    12241345        }
    12251346
    1226         /**
    1227          * Encrypts the given plaintext with the given key
    1228          * using CipherBlockChaining
    1229          */
     1347        ///<summary>
     1348        ///Encrypts the given plaintext with the given key
     1349        ///using CipherBlockChaining
     1350        ///</summary>
    12301351        public void encrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key, byte[] vector)
    12311352        {
     
    12551376        }//end encrypt
    12561377
    1257         /**
    1258          * Decrypts the given plaintext with the given Key
    1259          * using CipherBlockChaining
    1260          */
     1378        ///<summary>
     1379        ///Decrypts the given plaintext with the given Key
     1380        ///using CipherBlockChaining
     1381        ///</summary>
    12611382        public void decrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key, byte[] vector)
    12621383        {
     
    12841405        }//end decrypt
    12851406
    1286     }
    1287 
    1288     /**
    1289     *
    1290     * Encapsulates the ElectronicCodeBook algorithm
    1291     *
    1292     **/
     1407    }//end class CipherBlockChaining
     1408
     1409    ///<summary>
     1410    ///Encapsulates the ElectronicCodeBook algorithm
     1411    ///</summary>
    12931412    public class ElectronicCodeBook
    12941413    {
     
    12971416        private SDES_algorithm mAlgorithm;
    12981417
     1418        /// <summary>
     1419        /// Constructs a ElectronicCodeBook for SDES
     1420        /// </summary>
     1421        /// <param name="sdes">plugin</param>
    12991422        public ElectronicCodeBook(SDES sdes)
    13001423        {
     
    13031426        }
    13041427
    1305 
    1306         /**
    1307          * Encrypts the given plaintext with the given key
    1308          * using ElectronicCodeBookMode
    1309          */
     1428        ///
     1429        ///Encrypts the given plaintext with the given key
     1430        ///using ElectronicCodeBookMode
     1431        ///
    13101432        public void encrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key)
    13111433        {
     
    13321454        }//end encrypt
    13331455
    1334         /**
    1335          * Decrypts the given plaintext with the given Key
    1336          * using ElectronicCodeBook mode
    1337          */
     1456        ///<summary>
     1457        ///Decrypts the given plaintext with the given Key
     1458        ///using ElectronicCodeBook mode
     1459        ///</summary>
    13381460        public void decrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key)
    13391461        {
     
    13601482        }//end decrypt
    13611483
    1362     }
    1363 
    1364 }
     1484    }//end class ElectronicCodeBook
     1485
     1486}//end namespace Cryptool.Plugins.Cryptography.Encryption
  • trunk/CrypPlugins/SDES/SDESSettings.cs

    r513 r726  
    1414   limitations under the License.
    1515*/
    16 
    1716using System;
    1817using System.Collections.Generic;
     
    2625namespace Cryptool.Plugins.Cryptography.Encryption
    2726{
     27    /// <summary>
     28    /// Settings for the SDES plugin
     29    /// </summary>
    2830    public class SDESSettings : ISettings
    2931    {
     32        #region private
     33
    3034        private bool hasChanges = false;
    3135        private int action = 0; //0=encrypt, 1=decrypt
    3236        private int mode = 0; //0="ECB", 1="CBC"
     37     
     38        #endregion
     39       
     40        #region events
    3341
     42        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     43        public event StatusChangedEventHandler OnPluginStatusChanged;
     44
     45        #endregion
     46
     47        #region public
     48
     49        /// <summary>
     50        /// Gets/Sets the action of this plugin. Do you want the input data to be encrypted or decrypted?
     51        /// 1 = Encrypt
     52        /// 2 = Decrypt
     53        /// </summary>
    3454        [ContextMenu("Action","Do you want the input data to be encrypted or decrypted?",1, DisplayLevel.Beginner, ContextMenuControlType.ComboBox, new int[] { 1, 2}, "Encrypt","Decrypt")]
    3555        [TaskPane("Action", "Do you want the input data to be encrypted or decrypted?", null, 1, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Encrypt", "Decrypt" })]
     
    4565        }
    4666
     67        /// <summary>
     68        /// Sets the block cipher mode of this plugin
     69        /// 1 = ECB
     70        /// 2 = CBC
     71        /// </summary>
    4772        [ContextMenu("Chaining mode","Select the block cipher mode of operation.",2,DisplayLevel.Beginner,ContextMenuControlType.ComboBox,null, new String[] {"Electronic Code Book (ECB)","Cipher Block Chaining (CBC)" })]
    4873        [TaskPane("Chaining Mode", "Select the block cipher mode of operation.", null, 2, false, DisplayLevel.Experienced, ControlType.ComboBox, new String[] { "Electronic Bode Book (ECB)","Cipher Block Chaining (CBC)", })]
     
    5883        }
    5984
     85        /// <summary>
     86        /// Did the plugins properties change?
     87        /// </summary>
    6088        public bool HasChanges
    6189        {
     
    6492        }
    6593
    66         #region INotifyPropertyChanged Members
     94        #endregion
    6795
    68         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     96        #region private/protecte
    6997
     98        /// <summary>
     99        /// A property changed
     100        /// </summary>
     101        /// <param name="name"></param>
    70102        protected void OnPropertyChanged(string name)
    71103        {
     
    76108        }
    77109
    78         #endregion
    79 
    80         public event StatusChangedEventHandler OnPluginStatusChanged;
    81 
     110        /// <summary>
     111        /// Change the plugins icon (used for encryption/decryption icon)
     112        /// </summary>
     113        /// <param name="Icon">icon number</param>
    82114        private void ChangePluginIcon(int Icon)
    83115        {
     
    85117        }
    86118
     119        #endregion
    87120    }
    88 }
     121
     122}//end namespace Cryptool.Plugins.Cryptography.Encryption
Note: See TracChangeset for help on using the changeset viewer.