Changeset 8654


Ignore:
Timestamp:
Feb 22, 2020, 1:29:31 PM (2 years ago)
Author:
Christian Bender
Message:

Speck: small improvements

Location:
trunk/CrypPlugins/Speck
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Speck/Properties/Resources.Designer.cs

    r8586 r8654  
    404404       
    405405        /// <summary>
    406         ///   Sucht eine lokalisierte Zeichenfolge, die The input stream is too short. {0} bytes are missing or a padding mode must be selected. ähnelt.
    407         /// </summary>
    408         internal static string Speck_Input_too_short_multipleByte {
    409             get {
    410                 return ResourceManager.GetString("Speck_Input_too_short_multipleByte", resourceCulture);
    411             }
    412         }
    413        
    414         /// <summary>
    415         ///   Sucht eine lokalisierte Zeichenfolge, die The input stream is too short. {0} byte is missing or a padding mode must be selected. ähnelt.
    416         /// </summary>
    417         internal static string Speck_Input_too_short_singleByte {
    418             get {
    419                 return ResourceManager.GetString("Speck_Input_too_short_singleByte", resourceCulture);
     406        ///   Sucht eine lokalisierte Zeichenfolge, die The plaintext/ciphertext input stream is too short. Check blocklength of your input (see blocklength of selected Speck variant) or a padding mode must be selected. ähnelt.
     407        /// </summary>
     408        internal static string Speck_Input_too_short {
     409            get {
     410                return ResourceManager.GetString("Speck_Input_too_short", resourceCulture);
    420411            }
    421412        }
  • trunk/CrypPlugins/Speck/Properties/Resources.de.resx

    r8586 r8654  
    259259    <value>Der Eingabestrom wurde mittels {0} gepadded</value>
    260260  </data>
    261   <data name="Speck_Input_too_short_singleByte" xml:space="preserve">
    262     <value>Der Eingabestrom ist zu kurz. Es fehlt {0} Byte oder es muss ein Padding-Modus ausgewählt werden.</value>
    263   </data>
    264   <data name="Speck_Input_too_short_multipleByte" xml:space="preserve">
    265     <value>Der Eingabestrom ist zu kurz. Es fehlen {0} Bytes oder es muss ein Padding-Modus ausgewählt werden.</value>
     261  <data name="Speck_Input_too_short" xml:space="preserve">
     262    <value>Der Klartext/Geheimtext-Eingangsstrom ist zu kurz. Prüfen Sie die Blocklänge Ihrer Eingabe (siehe Blocklänge der gewählten Speck-Variante) oder es  oder es muss ein Padding-Modus ausgewählt werden.</value>
    266263  </data>
    267264  <data name="Speck_IV_too_long" xml:space="preserve">
  • trunk/CrypPlugins/Speck/Properties/Resources.resx

    r8577 r8654  
    259259    <value>The input stream was padded with {0}</value>
    260260  </data>
    261   <data name="Speck_Input_too_short_singleByte" xml:space="preserve">
    262     <value>The input stream is too short. {0} byte is missing or a padding mode must be selected.</value>
    263   </data>
    264   <data name="Speck_Input_too_short_multipleByte" xml:space="preserve">
    265     <value>The input stream is too short. {0} bytes are missing or a padding mode must be selected.</value>
     261  <data name="Speck_Input_too_short" xml:space="preserve">
     262    <value>The plaintext/ciphertext input stream is too short. Check blocklength of your input (see blocklength of selected Speck variant) or a padding mode must be selected.</value>
    266263  </data>
    267264  <data name="Speck_IV_too_long" xml:space="preserve">
  • trunk/CrypPlugins/Speck/Speck.cs

    r8586 r8654  
    1717using System;
    1818using System.ComponentModel;
     19using System.Diagnostics.CodeAnalysis;
    1920using System.Windows.Controls;
    2021using Cryptool.PluginBase;
     
    2425using Speck.Properties;
    2526
     27// ReSharper disable once IdentifierTypo
     28// ReSharper disable once CheckNamespace
    2629namespace Cryptool.Plugins.Speck
    2730{
    2831    [Author("Christian Bender", "christian1.bender@student.uni-siegen.de", null, "http://www.uni-siegen.de")]
    29     [PluginInfo("Speck.Properties.Resources", "PluginCaption", "PluginTooltip", "Speck/userdoc.xml", "Speck/Images/IC_Speck2.png")]
     32    [PluginInfo("Speck.Properties.Resources", "PluginCaption", "PluginTooltip", "Speck/userdoc.xml",
     33        "Speck/Images/IC_Speck2.png")]
    3034    [ComponentCategory(ComponentCategory.CiphersModernSymmetric)]
     35    [SuppressMessage("ReSharper", "RedundantDelegateCreation")]
    3136    public class Speck : ICrypComponent
    3237    {
    3338        #region Private Variables
    3439
    35         private readonly SpeckSettings settings = new SpeckSettings();
     40        private readonly SpeckSettings _settings = new SpeckSettings();
    3641        private ICryptoolStream _inputStream;
    3742        private ICryptoolStream _outputStream;
    3843        private byte[] _inputKey;
     44        // ReSharper disable once InconsistentNaming
    3945        private byte[] _inputIV;
    4046
     
    6167        public byte[] InputKey
    6268        {
    63             get
    64             {
    65                 return _inputKey;
    66             }
     69            get { return _inputKey; }
    6770            set
    6871            {
     
    7578        public ICryptoolStream OutputStream
    7679        {
    77             get
    78             {
    79                 return _outputStream;
    80             }
     80            get { return _outputStream; }
    8181            set
    8282            {
     
    8989        public byte[] InputIV
    9090        {
    91             get
    92             {
    93                 return _inputIV;
    94             }
    95             set
    96             {
    97                 _inputIV = value;
    98             }
     91            get { return _inputIV; }
     92            set { _inputIV = value; }
    9993        }
    10094
     
    108102        public ISettings Settings
    109103        {
    110             get { return settings; }
     104            get { return _settings; }
    111105        }
    112106
     
    136130
    137131            //Cut key to length
    138            if (_inputKey.Length > (settings.KeySize_mn / 8))
    139             {
    140                 byte[] key = new byte[settings.KeySize_mn / 8];
     132            if (_inputKey.Length > (_settings.KeySize_mn / 8))
     133            {
     134                byte[] key = new byte[_settings.KeySize_mn / 8];
    141135                Array.Copy(_inputKey, 0, key, 0, key.Length);
    142                 GuiLogMessage(String.Format(Resources.Speck_Execute_Key_too_long, _inputKey.Length, key.Length), NotificationLevel.Warning);
     136                GuiLogMessage(String.Format(Resources.Speck_Execute_Key_too_long, _inputKey.Length, key.Length),
     137                    NotificationLevel.Info);
    143138                _inputKey = key;
    144             }else if (_inputKey.Length < (settings.KeySize_mn / 8))
    145            {
    146                 GuiLogMessage(String.Format(Resources.Speck_Execute_Key_too_short, _inputKey.Length, (settings.KeySize_mn / 8)), NotificationLevel.Error);
     139            }
     140            else if (_inputKey.Length < (_settings.KeySize_mn / 8))
     141            {
     142                GuiLogMessage(
     143                    String.Format(Resources.Speck_Execute_Key_too_short, _inputKey.Length, (_settings.KeySize_mn / 8)),
     144                    NotificationLevel.Error);
    147145                return;
    148            }
     146            }
    149147
    150148            //Check for padding
    151             if (settings.OpMode == OperatingMode.Encrypt && (_inputStream.Length % (settings.BlockSize_2n / 8)) != 0)
    152             {
    153                 if (settings.PadMode != BlockCipherHelper.PaddingType.None)
     149            if (_settings.OpMode == OperatingMode.Encrypt && (_inputStream.Length % (_settings.BlockSize_2n / 8)) != 0)
     150            {
     151                if (_settings.PadMode != BlockCipherHelper.PaddingType.None)
    154152                {
    155153                    //in case of encryption, we have to add padding
    156                     _inputStream = BlockCipherHelper.AppendPadding(_inputStream, settings.PadMode, (settings.BlockSize_2n / 8));
    157                     GuiLogMessage(String.Format(Resources.Speck_Input_padded, settings.PadMode), NotificationLevel.Warning);
     154                    _inputStream =
     155                        BlockCipherHelper.AppendPadding(_inputStream, _settings.PadMode, (_settings.BlockSize_2n / 8));
     156                    GuiLogMessage(String.Format(Resources.Speck_Input_padded, _settings.PadMode),
     157                        NotificationLevel.Info);
    158158                }
    159159                else
    160160                {
    161                     int missingBytes = (int)((settings.BlockSize_2n / 8) -
    162                                         (_inputStream.Length % (settings.BlockSize_2n / 8)));
    163 
    164                     //check if a single or multiple byte
    165                     GuiLogMessage(
    166                         missingBytes == 1
    167                             ? String.Format(Resources.Speck_Input_too_short_singleByte,
    168                                 ((settings.BlockSize_2n / 8) - (_inputStream.Length % (settings.BlockSize_2n / 8))))
    169                             : String.Format(Resources.Speck_Input_too_short_multipleByte,
    170                                 ((settings.BlockSize_2n / 8) - (_inputStream.Length % (settings.BlockSize_2n / 8)))),
    171                         NotificationLevel.Warning);
     161                    //message to the user and abort
     162                    GuiLogMessage(Resources.Speck_Input_too_short, NotificationLevel.Error);
    172163                    return;
    173164                }
     
    177168            CryptoFunction cryptoFunction = null;
    178169
    179            if (settings.ChoiceOfVariant == SpeckParameters.Speck32_64)
    180            {
    181                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    182                    cryptoFunction = SpeckCiphers.Speck32_64_Encryption;
    183                else
    184                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck32_64_Decryption);
    185            }
    186            else if (settings.ChoiceOfVariant == SpeckParameters.Speck48_72)
    187            {
    188                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    189                    cryptoFunction = SpeckCiphers.Speck48_72_Encryption;
    190                else
    191                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck48_72_Decryption);
    192            }
    193            else if (settings.ChoiceOfVariant == SpeckParameters.Speck48_96)
    194            {
    195                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    196                    cryptoFunction = SpeckCiphers.Speck48_96_Encryption;
    197                else
    198                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck48_96_Decryption);
    199            }
    200            else if (settings.ChoiceOfVariant == SpeckParameters.Speck64_96)
    201            {
    202                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    203                    cryptoFunction = SpeckCiphers.Speck64_96_Encryption;
    204                else
    205                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck64_96_Decryption);
    206            }
    207            else if (settings.ChoiceOfVariant == SpeckParameters.Speck64_128)
    208            {
    209                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    210                    cryptoFunction = SpeckCiphers.Speck64_128_Encryption;
    211                else
    212                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck64_128_Decryption);
    213            }
    214            else if (settings.ChoiceOfVariant == SpeckParameters.Speck96_96)
    215            {
    216                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    217                    cryptoFunction = SpeckCiphers.Speck96_96_Encryption;
    218                else
    219                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck96_96_Decryption);
    220            }
    221            else if (settings.ChoiceOfVariant == SpeckParameters.Speck96_144)
    222            {
    223                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    224                    cryptoFunction = SpeckCiphers.Speck96_144_Encryption;
    225                else
    226                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck96_144_Decryption);
    227            }
    228            else if (settings.ChoiceOfVariant == SpeckParameters.Speck128_128)
    229            {
    230                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    231                    cryptoFunction = SpeckCiphers.Speck128_128_Encryption;
    232                else
    233                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck128_128_Decryption);
    234            }
    235            else if (settings.ChoiceOfVariant == SpeckParameters.Speck128_192)
    236            {
    237                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    238                    cryptoFunction = SpeckCiphers.Speck128_192_Encryption;
    239                else
    240                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck128_192_Decryption);
    241            }
    242            else if (settings.ChoiceOfVariant == SpeckParameters.Speck128_256)
    243            {
    244                if (settings.OpMode == OperatingMode.Encrypt || settings.OperationMode == ModeOfOperation.CipherFeedback || settings.OperationMode == ModeOfOperation.OutputFeedback)
    245                    cryptoFunction = SpeckCiphers.Speck128_256_Encryption;
    246                else
    247                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck128_256_Decryption);
    248            }
    249 
    250            //Check, if we found a crypto function that we can use
    251            //this error should NEVER occur.
    252            if (cryptoFunction == null)
    253            {
    254                GuiLogMessage(Resources.Speck_no_cryptofunction, NotificationLevel.Error);
    255                return;
    256            }
     170            if (_settings.ChoiceOfVariant == SpeckParameters.Speck32_64)
     171            {
     172                if (_settings.OpMode == OperatingMode.Encrypt ||
     173                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     174                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     175                    cryptoFunction = SpeckCiphers.Speck32_64_Encryption;
     176                else
     177                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck32_64_Decryption);
     178            }
     179            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck48_72)
     180            {
     181                if (_settings.OpMode == OperatingMode.Encrypt ||
     182                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     183                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     184                    cryptoFunction = SpeckCiphers.Speck48_72_Encryption;
     185                else
     186                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck48_72_Decryption);
     187            }
     188            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck48_96)
     189            {
     190                if (_settings.OpMode == OperatingMode.Encrypt ||
     191                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     192                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     193                    cryptoFunction = SpeckCiphers.Speck48_96_Encryption;
     194                else
     195                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck48_96_Decryption);
     196            }
     197            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck64_96)
     198            {
     199                if (_settings.OpMode == OperatingMode.Encrypt ||
     200                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     201                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     202                    cryptoFunction = SpeckCiphers.Speck64_96_Encryption;
     203                else
     204                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck64_96_Decryption);
     205            }
     206            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck64_128)
     207            {
     208                if (_settings.OpMode == OperatingMode.Encrypt ||
     209                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     210                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     211                    cryptoFunction = SpeckCiphers.Speck64_128_Encryption;
     212                else
     213                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck64_128_Decryption);
     214            }
     215            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck96_96)
     216            {
     217                if (_settings.OpMode == OperatingMode.Encrypt ||
     218                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     219                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     220                    cryptoFunction = SpeckCiphers.Speck96_96_Encryption;
     221                else
     222                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck96_96_Decryption);
     223            }
     224            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck96_144)
     225            {
     226                if (_settings.OpMode == OperatingMode.Encrypt ||
     227                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     228                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     229                    cryptoFunction = SpeckCiphers.Speck96_144_Encryption;
     230                else
     231                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck96_144_Decryption);
     232            }
     233            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck128_128)
     234            {
     235                if (_settings.OpMode == OperatingMode.Encrypt ||
     236                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     237                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     238                    cryptoFunction = SpeckCiphers.Speck128_128_Encryption;
     239                else
     240                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck128_128_Decryption);
     241            }
     242            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck128_192)
     243            {
     244                if (_settings.OpMode == OperatingMode.Encrypt ||
     245                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     246                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     247                    cryptoFunction = SpeckCiphers.Speck128_192_Encryption;
     248                else
     249                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck128_192_Decryption);
     250            }
     251            else if (_settings.ChoiceOfVariant == SpeckParameters.Speck128_256)
     252            {
     253                if (_settings.OpMode == OperatingMode.Encrypt ||
     254                    _settings.OperationMode == ModeOfOperation.CipherFeedback ||
     255                    _settings.OperationMode == ModeOfOperation.OutputFeedback)
     256                    cryptoFunction = SpeckCiphers.Speck128_256_Encryption;
     257                else
     258                    cryptoFunction = new CryptoFunction(SpeckCiphers.Speck128_256_Decryption);
     259            }
     260
     261            //Check, if we found a crypto function that we can use
     262            //this error should NEVER occur.
     263            if (cryptoFunction == null)
     264            {
     265                GuiLogMessage(Resources.Speck_no_cryptofunction, NotificationLevel.Error);
     266                return;
     267            }
    257268
    258269            //Select block mode and execute cryptoFunction
    259             switch (settings.OperationMode)
    260            {
     270            switch (_settings.OperationMode)
     271            {
    261272                case ModeOfOperation.ElectronicCodeBook:
    262273                    Execute_ECB(cryptoFunction);
     
    276287
    277288                default:
    278                     throw new NotImplementedException(String.Format(Resources.Speck_blockmode_not_implemented, settings.OperationMode));
     289                    throw new NotImplementedException(String.Format(Resources.Speck_blockmode_not_implemented,
     290                        _settings.OperationMode));
    279291            }
    280292
     
    316328        #region Encryption/Decryption
    317329
     330        // ReSharper disable once InconsistentNaming
    318331        private void CheckIV()
    319332        {
    320             int neededBlockLength = settings.BlockSize_2n / 8;
     333            int neededBlockLength = _settings.BlockSize_2n / 8;
    321334
    322335            //if no IV is given, we set it to an array with needed block length
     
    335348            }
    336349
    337             if(_inputIV.Length > neededBlockLength)
     350            if (_inputIV.Length > neededBlockLength)
    338351            {
    339352                byte[] iv = new byte[neededBlockLength];
     
    342355                _inputIV = iv;
    343356            }
    344 
    345357        }
    346358
     
    355367                using (CStreamWriter writer = new CStreamWriter())
    356368                {
    357                     byte[] inputBlock = new byte[settings.BlockSize_2n / 8];
    358                     int readcount = 0;
     369                    byte[] inputBlock = new byte[_settings.BlockSize_2n / 8];
     370                    int readcount;
    359371
    360372                    while (reader.Position < reader.Length && !_stop)
    361373                    {
    362374                        readcount = 0;
    363                         while ((readcount += reader.Read(inputBlock, readcount, inputBlock.Length - readcount)) < inputBlock.Length &&
     375                        while ((readcount += reader.Read(inputBlock, readcount, inputBlock.Length - readcount)) <
     376                               inputBlock.Length &&
    364377                               reader.Position < reader.Length && !_stop)
    365378                        {
     
    374387                        ProgressChanged(reader.Position, reader.Length);
    375388
    376                         byte[] outputBlock = null;
    377                         outputBlock = cryptoFunction(inputBlock, _inputKey);
     389                        var outputBlock = cryptoFunction(inputBlock, _inputKey);
    378390
    379391                        //if we (de)crypted something, we output it
     
    382394                            writer.Write(outputBlock, 0, outputBlock.Length);
    383395                        }
    384 
    385396                    }
    386397
     
    401412                using (CStreamWriter writer = new CStreamWriter())
    402413                {
    403 
    404414                    byte[] lastBlock = InputIV;
    405                     int readcount = 0;
    406415
    407416                    while (reader.Position < reader.Length && !_stop)
    408417                    {
    409418                        //we always try to read a complete block (=8 bytes)
    410                         byte[] inputBlock = new byte[settings.BlockSize_2n / 8];
    411                         readcount = 0;
    412                         while ((readcount += reader.Read(inputBlock, readcount, (settings.BlockSize_2n / 8) - readcount)) < (settings.BlockSize_2n / 8) &&
    413                                reader.Position < reader.Length && !_stop) ;
     419                        byte[] inputBlock = new byte[_settings.BlockSize_2n / 8];
     420                        var readcount = 0;
     421                        while ((readcount +=
     422                                   reader.Read(inputBlock, readcount, (_settings.BlockSize_2n / 8) - readcount)) <
     423                               (_settings.BlockSize_2n / 8) &&
     424                               reader.Position < reader.Length && !_stop)
     425                        {
     426                        }
     427
    414428                        if (_stop)
    415429                        {
     
    422436                        byte[] outputBlock = null;
    423437                        //we read a complete block
    424                         if (readcount == (settings.BlockSize_2n / 8))
     438                        if (readcount == (_settings.BlockSize_2n / 8))
    425439                        {
    426440                            //Compute XOR with lastblock for CBC mode
    427                             if (settings.OpMode == OperatingMode.Encrypt)
     441                            if (_settings.OpMode == OperatingMode.Encrypt)
    428442                            {
    429443                                inputBlock = SpeckCiphers.Xor(inputBlock, lastBlock);
     
    442456                        {
    443457                            //Compute XOR with lastblock for CBC mode
    444                             if (settings.OpMode == OperatingMode.Encrypt)
    445                             {
    446                                 byte[] block = new byte[settings.BlockSize_2n / 8];
     458                            if (_settings.OpMode == OperatingMode.Encrypt)
     459                            {
     460                                byte[] block = new byte[_settings.BlockSize_2n / 8];
    447461                                Array.Copy(inputBlock, 0, block, 0, readcount);
    448462                                inputBlock = SpeckCiphers.Xor(block, lastBlock);
     
    457471
    458472                        //check if it is the last block and we decrypt, thus, we have to remove the padding
    459                         if (reader.Position == reader.Length && settings.OpMode == OperatingMode.Decrypt && settings.PadMode != BlockCipherHelper.PaddingType.None)
    460                         {
    461                             int valid = BlockCipherHelper.StripPadding(outputBlock, (settings.BlockSize_2n / 8), settings.PadMode, (settings.BlockSize_2n / 8));
    462                             if (valid != settings.BlockSize_2n / 8)
     473                        if (reader.Position == reader.Length && _settings.OpMode == OperatingMode.Decrypt &&
     474                            _settings.PadMode != BlockCipherHelper.PaddingType.None)
     475                        {
     476                            int valid = BlockCipherHelper.StripPadding(outputBlock, (_settings.BlockSize_2n / 8),
     477                                _settings.PadMode, (_settings.BlockSize_2n / 8));
     478                            if (valid != _settings.BlockSize_2n / 8)
    463479                            {
    464480                                byte[] newOutputBlock = new byte[valid];
     
    497513                {
    498514                    byte[] lastBlock = InputIV;
    499                     int readcount = 0;
    500515
    501516                    while (reader.Position < reader.Length && !_stop)
    502517                    {
    503518                        //we always try to read a complete block (=8 bytes)
    504                         byte[] inputBlock = new byte[(settings.BlockSize_2n / 8)];
    505                         readcount = 0;
    506                         while ((readcount += reader.Read(inputBlock, readcount, (settings.BlockSize_2n / 8) - readcount)) < (settings.BlockSize_2n / 8) &&
    507                                reader.Position < reader.Length && !_stop) ;
     519                        byte[] inputBlock = new byte[(_settings.BlockSize_2n / 8)];
     520                        var readcount = 0;
     521                        while ((readcount +=
     522                                   reader.Read(inputBlock, readcount, (_settings.BlockSize_2n / 8) - readcount)) <
     523                               (_settings.BlockSize_2n / 8) &&
     524                               reader.Position < reader.Length && !_stop)
     525                        {
     526                        }
    508527
    509528                        if (_stop)
     
    517536                        byte[] outputblock = null;
    518537                        //we read a complete block
    519                         if (readcount == (settings.BlockSize_2n / 8))
     538                        if (readcount == (_settings.BlockSize_2n / 8))
    520539                        {
    521540                            //Compute XOR with lastblock for CFB mode
    522                             if (settings.OpMode == OperatingMode.Encrypt)
     541                            if (_settings.OpMode == OperatingMode.Encrypt)
    523542                            {
    524543                                outputblock = cryptoFunction(lastBlock, _inputKey);
     
    537556                        {
    538557                            //Compute XOR with lastblock for CFB mode
    539                             if (settings.OpMode == OperatingMode.Encrypt)
    540                             {
    541                                 byte[] block = new byte[(settings.BlockSize_2n / 8)];
     558                            if (_settings.OpMode == OperatingMode.Encrypt)
     559                            {
     560                                byte[] block = new byte[(_settings.BlockSize_2n / 8)];
    542561                                Array.Copy(inputBlock, 0, block, 0, readcount);
    543562                                outputblock = cryptoFunction(lastBlock, _inputKey);
     
    546565                            else
    547566                            {
    548                                 byte[] block = new byte[(settings.BlockSize_2n / 8)];
     567                                byte[] block = new byte[(_settings.BlockSize_2n / 8)];
    549568                                Array.Copy(inputBlock, 0, block, 0, readcount);
    550569                                outputblock = cryptoFunction(inputBlock, _inputKey);
     
    554573
    555574                        //check if it is the last block and we decrypt, thus, we have to remove the padding
    556                         if (reader.Position == reader.Length && settings.OpMode == OperatingMode.Decrypt && settings.PadMode != BlockCipherHelper.PaddingType.None)
    557                         {
    558                             int valid = BlockCipherHelper.StripPadding(outputblock, (settings.BlockSize_2n / 8), settings.PadMode, (settings.BlockSize_2n / 8));
    559                             if (valid != (settings.BlockSize_2n / 8))
     575                        if (reader.Position == reader.Length && _settings.OpMode == OperatingMode.Decrypt &&
     576                            _settings.PadMode != BlockCipherHelper.PaddingType.None)
     577                        {
     578                            int valid = BlockCipherHelper.StripPadding(outputblock, (_settings.BlockSize_2n / 8),
     579                                _settings.PadMode, (_settings.BlockSize_2n / 8));
     580                            if (valid != (_settings.BlockSize_2n / 8))
    560581                            {
    561582                                byte[] newoutputblock = new byte[valid];
     
    594615                {
    595616                    byte[] lastBlock = InputIV;
    596                     int readcount = 0;
    597617
    598618                    while (reader.Position < reader.Length && !_stop)
    599619                    {
    600620                        //we always try to read a complete block (=(settings.BlockSize_2n / 8) bytes)
    601                         byte[] inputBlock = new byte[(settings.BlockSize_2n / 8)];
    602                         readcount = 0;
    603                         while ((readcount += reader.Read(inputBlock, readcount, (settings.BlockSize_2n / 8) - readcount)) < (settings.BlockSize_2n / 8) &&
    604                                reader.Position < reader.Length && !_stop) ;
     621                        byte[] inputBlock = new byte[(_settings.BlockSize_2n / 8)];
     622                        var readcount = 0;
     623                        while ((readcount +=
     624                                   reader.Read(inputBlock, readcount, (_settings.BlockSize_2n / 8) - readcount)) <
     625                               (_settings.BlockSize_2n / 8) &&
     626                               reader.Position < reader.Length && !_stop)
     627                        {
     628                        }
     629
    605630                        if (_stop)
    606631                        {
     
    613638                        byte[] outputblock = null;
    614639                        //we read a complete block
    615                         if (readcount == (settings.BlockSize_2n / 8))
     640                        if (readcount == (_settings.BlockSize_2n / 8))
    616641                        {
    617642                            //Compute XOR with lastblock for OFB mode
    618                             if (settings.OpMode == OperatingMode.Encrypt)
     643                            if (_settings.OpMode == OperatingMode.Encrypt)
    619644                            {
    620645                                outputblock = cryptoFunction(lastBlock, _inputKey);
     
    633658                        {
    634659                            //Compute XOR with lastblock for CFB mode
    635                             if (settings.OpMode == OperatingMode.Encrypt)
    636                             {
    637                                 byte[] block = new byte[(settings.BlockSize_2n / 8)];
     660                            if (_settings.OpMode == OperatingMode.Encrypt)
     661                            {
     662                                byte[] block = new byte[(_settings.BlockSize_2n / 8)];
    638663                                Array.Copy(inputBlock, 0, block, 0, readcount);
    639664                                outputblock = cryptoFunction(lastBlock, _inputKey);
     
    642667                            else
    643668                            {
    644                                 byte[] block = new byte[(settings.BlockSize_2n / 8)];
     669                                byte[] block = new byte[(_settings.BlockSize_2n / 8)];
    645670                                Array.Copy(inputBlock, 0, block, 0, readcount);
    646671                                outputblock = cryptoFunction(inputBlock, _inputKey);
     
    650675
    651676                        //check if it is the last block and we decrypt, thus, we have to remove the padding
    652                         if (reader.Position == reader.Length && settings.OpMode == OperatingMode.Decrypt && settings.PadMode != BlockCipherHelper.PaddingType.None)
    653                         {
    654                             int valid = BlockCipherHelper.StripPadding(outputblock, (settings.BlockSize_2n / 8), settings.PadMode, (settings.BlockSize_2n / 8));
    655                             if (valid != (settings.BlockSize_2n / 8))
     677                        if (reader.Position == reader.Length && _settings.OpMode == OperatingMode.Decrypt &&
     678                            _settings.PadMode != BlockCipherHelper.PaddingType.None)
     679                        {
     680                            int valid = BlockCipherHelper.StripPadding(outputblock, (_settings.BlockSize_2n / 8),
     681                                _settings.PadMode, (_settings.BlockSize_2n / 8));
     682                            if (valid != (_settings.BlockSize_2n / 8))
    656683                            {
    657684                                byte[] newoutputblock = new byte[valid];
    658                                 Array.Copy(outputblock, 0, newoutputblock, 0, valid);
     685                                if (outputblock != null) Array.Copy(outputblock, 0, newoutputblock, 0, valid);
    659686                                outputblock = newoutputblock;
    660687                            }
Note: See TracChangeset for help on using the changeset viewer.