Changeset 2670


Ignore:
Timestamp:
Feb 12, 2011, 2:15:06 AM (11 years ago)
Author:
Matthäus Wander
Message:

fixed some potential ICryptoolStream bugs (which may occur under special circumstances)

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginBase/IO/CStreamReader.cs

    r2669 r2670  
    9292        }
    9393
     94        /// <summary>
     95        /// Caveat: The length may grow while the writer has not closed the stream. If you rely on Length, you may want to call WaitEof() before.
     96        /// </summary>
    9497        public override long Length
    9598        {
  • trunk/CrypPlugins/AES/AES.cs

    r2529 r2670  
    246246                using (CStreamReader reader = InputStream.CreateReader())
    247247                {
    248                     p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read);
     248                    p_crypto_stream = new CryptoStream(reader, p_encryptor, CryptoStreamMode.Read);
    249249            byte[] buffer = new byte[p_alg.BlockSize / 8];
    250250            int bytesRead;
  • trunk/CrypPlugins/CRC/CRC.cs

    r2529 r2670  
    136136                while ((readCount = reader.Read(input)) > 0)
    137137                {
    138                 for (int i = 0; i < readCount; ++i)
    139                 {
    140                     byte index = (byte)(((crc) & 0xff) ^ input[i]);
    141                     crc = (uint)((crc >> 8) ^ table[index]);
     138                    for (int i = 0; i < readCount; ++i)
     139                    {
     140                        byte index = (byte)(((crc) & 0xff) ^ input[i]);
     141                        crc = (uint)((crc >> 8) ^ table[index]);
     142                    }
     143
     144                    ProgressChanged((double)reader.Position / reader.Length, 1.0);
    142145                }
    143 
    144                     ProgressChanged((double)reader.Position / reader.Length, 1.0);
    145             }
    146146            }
    147147
  • trunk/CrypPlugins/ClipboardOutput/ClipboardOutput.cs

    r2529 r2670  
    143143        using (CStreamReader reader = value.CreateReader())
    144144        {
     145            reader.WaitEof();
    145146            byte[] byteValues = new byte[reader.Length];
    146147            reader.Read(byteValues, 0, (int)reader.Length);
  • trunk/CrypPlugins/PKCS5/PKCS5.cs

    r2529 r2670  
    218218          using (CStreamReader cst = ((ICryptoolStream)value).CreateReader())
    219219          {
    220               /// FIXME: potentially broken. Shall not rely on Length property to return
    221               /// final value.
    222           long len = cst.Length;
    223           key = new byte[len];
    224 
    225           for (long i = 0; i < len; i++)
    226             key[i] = (byte)cst.ReadByte();
     220              cst.WaitEof();
     221
     222              long len = cst.Length;
     223              key = new byte[len];
     224
     225              for (long i = 0; i < len; i++)
     226                  key[i] = (byte)cst.ReadByte();
    227227          }
    228228
     
    299299          using (CStreamReader cst = ((ICryptoolStream)value).CreateReader())
    300300          {
    301               /// FIXME: potentially broken. Shall not rely on Length property to return
    302               /// final value.
    303           long len = cst.Length;
    304           salt = new byte[len];
    305 
    306           for (long i = 0; i < len; i++)
    307             salt[i] = (byte)cst.ReadByte();
    308         }
     301              cst.WaitEof();
     302              long len = cst.Length;
     303              salt = new byte[len];
     304
     305              for (long i = 0; i < len; i++)
     306                  salt[i] = (byte)cst.ReadByte();
     307          }
    309308        }
    310309        else if (value is byte[])
  • trunk/CrypPlugins/PeerToPeer/DHT_CommonManagement.cs

    r2529 r2670  
    8686                using (CStreamReader cReader = cStream.CreateReader())
    8787                {
     88                    cReader.WaitEof();
    8889                    // Convert CryptoolStream to an byte Array and store it in the DHT
    8990                    if (cReader.Length > Int32.MaxValue)
  • trunk/CrypPlugins/StreamComparator/StreamComparator.cs

    r2529 r2670  
    109109      using (CStreamReader readerOne = InputOne.CreateReader(), readerTwo = InputTwo.CreateReader())
    110110        {
     111          readerOne.WaitEof();
     112          readerTwo.WaitEof();
     113
    111114          if (readerOne.Length != readerTwo.Length && !settings.Diff)
    112115          {
     
    187190            using (CStreamReader readerOne = InputOne.CreateReader(), readerTwo = InputTwo.CreateReader())
    188191            {
     192                readerOne.WaitEof();
     193                readerTwo.WaitEof();
    189194
    190195                if (readerOne.Length > maxLength || readerTwo.Length > maxLength)
  • trunk/CrypPlugins/StreamToStringConverter/StreamToStringConverter.cs

    r2529 r2670  
    3131{
    3232    [Author("Dr. Arno Wacker", "arno.wacker@cryptool.org", "Uni Duisburg", "http://www.uni-duisburg-essen.de")]
    33     [PluginInfo(false, "Stream to String Converter", "Converts a given stream into a string.", "", "StreamToStringConverter/s2t-icon.png")]   
     33    [PluginInfo(false, "Stream to String Converter", "Converts a given stream into a string.", "", "StreamToStringConverter/s2t-icon.png")]
    3434    public class StreamToStringConverter : IThroughput
    35     {       
     35    {
    3636        #region Public interface
    3737
     
    6767        public object InputStreamQuickWatchConverter(string PropertyNameToConvert)
    6868        {
    69           return outputString;
     69            return outputString;
    7070        }
    7171
    7272        [PropertyInfo(Direction.InputData, "Stream input", "Input stream will be converted to ASCII text. The encoding given in the settings will be used.", "", true, false, QuickWatchFormat.Text, "InputStreamQuickWatchConverter")]
    7373        public ICryptoolStream InputStream
    74         {           
    75             get 
     74        {
     75            get
    7676            {
    7777                return inputStream;
    78               }
    79             set 
    80             {
    81               inputStream = value;
    82               // processInput(value); This should be done in execute method, because PlayMode causes
    83               // errors state (yellow/red markers) to be flushed on execute. So if input is processed
    84               // here before execute method the plugin element will not be colored correctly if
    85               // errors/warnings occur.
    86               OnPropertyChanged("InputStream");
     78            }
     79            set
     80            {
     81                inputStream = value;
     82                // processInput(value); This should be done in execute method, because PlayMode causes
     83                // errors state (yellow/red markers) to be flushed on execute. So if input is processed
     84                // here before execute method the plugin element will not be colored correctly if
     85                // errors/warnings occur.
     86                OnPropertyChanged("InputStream");
    8787            }
    8888        }
     
    109109        public UserControl QuickWatchPresentation
    110110        {
    111           get { return null; }
     111            get { return null; }
    112112        }
    113113
    114114        public void Initialize() { }
    115115
    116         public void Dispose() 
    117         {         
    118               inputStream = null;
    119           }
     116        public void Dispose()
     117        {
     118            inputStream = null;
     119        }
    120120
    121121
     
    125125        {
    126126            get { return settings.HasChanges; }
    127             set { settings.HasChanges = value;  }
     127            set { settings.HasChanges = value; }
    128128        }
    129129
     
    157157        private StreamToStringConverterSettings settings;
    158158        private ICryptoolStream inputStream = null;
    159         private string outputString;       
     159        private string outputString;
    160160        #endregion
    161161
     
    164164        private void processInput(CStreamReader value)
    165165        {
    166                 ShowProgress(50, 100);
    167                 ShowStatusBarMessage("Converting input ...", NotificationLevel.Debug);
    168                 if (value.Length > settings.MaxLength)
    169                   ShowStatusBarMessage("WARNING - Input stream is too large (" + (value.Length / 1024).ToString("0.00") + " kB), output will be truncated to " + (settings.MaxLength / 1024).ToString("0.00") + "kB", NotificationLevel.Warning);
    170 
    171                 byte[] byteValues = new byte[settings.MaxLength];
    172                 int bytesRead;
    173                 value.Seek(0, SeekOrigin.Begin);
    174                 bytesRead = value.Read(byteValues, 0, byteValues.Length);
    175                
    176                 // here conversion happens
    177                 switch (settings.Encoding)
    178                 {
    179                     case StreamToStringConverterSettings.EncodingTypes.Default:
    180                         outputString = Encoding.Default.GetString(byteValues, 0, bytesRead);
    181                         break;
    182                     case StreamToStringConverterSettings.EncodingTypes.Base64Binary:
    183                         outputString = Convert.ToBase64String(byteValues, 0, bytesRead);
    184                         break;
    185                     case StreamToStringConverterSettings.EncodingTypes.HexStringBinary:
    186                         outputString = convertBytesToHexString(byteValues, 0, bytesRead);
    187                         break;
    188                     case StreamToStringConverterSettings.EncodingTypes.OctalStringBinary:
    189                         outputString = convertBytesToOctalString(byteValues, 0, bytesRead);
    190                         break;
    191                     case StreamToStringConverterSettings.EncodingTypes.Unicode:
    192                         outputString = Encoding.Unicode.GetString(byteValues, 0, bytesRead);
    193                         break;
    194                     case StreamToStringConverterSettings.EncodingTypes.UTF7:
    195                         outputString = Encoding.UTF7.GetString(byteValues, 0, bytesRead);
    196                         break;
    197                     case StreamToStringConverterSettings.EncodingTypes.UTF8:
    198                         outputString = Encoding.UTF8.GetString(byteValues, 0, bytesRead);
    199                         break;
    200                     case StreamToStringConverterSettings.EncodingTypes.UTF32:
    201                         outputString = Encoding.UTF32.GetString(byteValues, 0, bytesRead);
    202                         break;
    203                     case StreamToStringConverterSettings.EncodingTypes.ASCII:
    204                         outputString = Encoding.ASCII.GetString(byteValues, 0, bytesRead);
    205                         break;
    206                     case StreamToStringConverterSettings.EncodingTypes.BigEndianUnicode:
    207                         outputString = Encoding.BigEndianUnicode.GetString(byteValues, 0, bytesRead);
    208                         break;
    209                     default:
    210                         outputString = Encoding.Default.GetString(byteValues, 0, bytesRead);
    211                         break;
    212                 }
    213 
    214                 ShowStatusBarMessage("Input converted.", NotificationLevel.Debug);
    215                 ShowProgress(100, 100);
    216                 OnPropertyChanged("InputStream");
    217                 OnPropertyChanged("OutputString");
    218             }
     166            ShowProgress(50, 100);
     167            ShowStatusBarMessage("Converting input ...", NotificationLevel.Debug);
     168            value.WaitEof();
     169            if (value.Length > settings.MaxLength)
     170                ShowStatusBarMessage("WARNING - Input stream is too large (" + (value.Length / 1024).ToString("0.00") + " kB), output will be truncated to " + (settings.MaxLength / 1024).ToString("0.00") + "kB", NotificationLevel.Warning);
     171
     172            byte[] byteValues = new byte[settings.MaxLength];
     173            int bytesRead;
     174            value.Seek(0, SeekOrigin.Begin);
     175            bytesRead = value.Read(byteValues, 0, byteValues.Length);
     176
     177            // here conversion happens
     178            switch (settings.Encoding)
     179            {
     180                case StreamToStringConverterSettings.EncodingTypes.Default:
     181                    outputString = Encoding.Default.GetString(byteValues, 0, bytesRead);
     182                    break;
     183                case StreamToStringConverterSettings.EncodingTypes.Base64Binary:
     184                    outputString = Convert.ToBase64String(byteValues, 0, bytesRead);
     185                    break;
     186                case StreamToStringConverterSettings.EncodingTypes.HexStringBinary:
     187                    outputString = convertBytesToHexString(byteValues, 0, bytesRead);
     188                    break;
     189                case StreamToStringConverterSettings.EncodingTypes.OctalStringBinary:
     190                    outputString = convertBytesToOctalString(byteValues, 0, bytesRead);
     191                    break;
     192                case StreamToStringConverterSettings.EncodingTypes.Unicode:
     193                    outputString = Encoding.Unicode.GetString(byteValues, 0, bytesRead);
     194                    break;
     195                case StreamToStringConverterSettings.EncodingTypes.UTF7:
     196                    outputString = Encoding.UTF7.GetString(byteValues, 0, bytesRead);
     197                    break;
     198                case StreamToStringConverterSettings.EncodingTypes.UTF8:
     199                    outputString = Encoding.UTF8.GetString(byteValues, 0, bytesRead);
     200                    break;
     201                case StreamToStringConverterSettings.EncodingTypes.UTF32:
     202                    outputString = Encoding.UTF32.GetString(byteValues, 0, bytesRead);
     203                    break;
     204                case StreamToStringConverterSettings.EncodingTypes.ASCII:
     205                    outputString = Encoding.ASCII.GetString(byteValues, 0, bytesRead);
     206                    break;
     207                case StreamToStringConverterSettings.EncodingTypes.BigEndianUnicode:
     208                    outputString = Encoding.BigEndianUnicode.GetString(byteValues, 0, bytesRead);
     209                    break;
     210                default:
     211                    outputString = Encoding.Default.GetString(byteValues, 0, bytesRead);
     212                    break;
     213            }
     214
     215            ShowStatusBarMessage("Input converted.", NotificationLevel.Debug);
     216            ShowProgress(100, 100);
     217            OnPropertyChanged("InputStream");
     218            OnPropertyChanged("OutputString");
     219        }
    219220
    220221        private string convertBytesToHexString(byte[] array, int start, int count)
    221         {
    222             StringBuilder sb = new StringBuilder();
    223             for (int i = start; i < (start+count); i++)
    224             {
    225                sb.Append(array[i].ToString("X2"));
    226                sb.Append(" ");
    227             }
    228             return sb.ToString();
    229         }
    230 
    231         private string convertBytesToOctalString(byte[] array, int start, int count)
    232222        {
    233223            StringBuilder sb = new StringBuilder();
    234224            for (int i = start; i < (start + count); i++)
    235225            {
    236                 string val = String.Format("{0,3}",Convert.ToString(array[i], 8));
    237                 sb.Append(val.Replace(' ','0'));
     226                sb.Append(array[i].ToString("X2"));
    238227                sb.Append(" ");
    239228            }
     
    241230        }
    242231
     232        private string convertBytesToOctalString(byte[] array, int start, int count)
     233        {
     234            StringBuilder sb = new StringBuilder();
     235            for (int i = start; i < (start + count); i++)
     236            {
     237                string val = String.Format("{0,3}", Convert.ToString(array[i], 8));
     238                sb.Append(val.Replace(' ', '0'));
     239                sb.Append(" ");
     240            }
     241            return sb.ToString();
     242        }
     243
    243244        private void ShowStatusBarMessage(string message, NotificationLevel logLevel)
    244245        {
    245           EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
     246            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
    246247        }
    247248
    248249        private void ShowProgress(double value, double max)
    249250        {
    250           EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
     251            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
    251252        }
    252253
     
    264265                {
    265266                    processInput(reader);
    266         }
     267                }
    267268            }
    268269            else
     
    274275        public void Pause()
    275276        {
    276          
     277
    277278        }
    278279
  • trunk/CrypPlugins/TEA/TEA.cs

    r2669 r2670  
    6262            get;
    6363            set;
    64               }
     64        }
    6565
    6666        [PropertyInfo(Direction.InputData, "Key", "Must be 16 bytes (128 bit).", "", true, false, QuickWatchFormat.Hex, null)]
     
    8080            {
    8181                return outputStream;
    82                 }
     82            }
    8383            set
    8484            {
     
    136136            //Encrypt/Decrypt Stream
    137137            try
    138             {               
     138            {
    139139                checkForInputStream();
    140140
     
    151151                    outputStream = new CStreamWriter();
    152152
    153 
    154153                    long inputbytes = reader.Length;
    155154                    GuiLogMessage("inputStream length [bytes]: " + inputbytes.ToString(), NotificationLevel.Debug);
    156155
    157                 int bytesRead = 0;
    158                 int blocksRead = 0;
    159                 int position;
    160                 int blocks;
    161 
    162                 // get number of blocks
    163                 if (((int)inputbytes % 8) == 0)
    164                 {
    165                     blocks = (int)inputbytes / 8;
     156                    int bytesRead = 0;
     157                    int blocksRead = 0;
     158                    int position;
     159                    int blocks;
     160
     161                    // get number of blocks
     162                    if (((int)inputbytes % 8) == 0)
     163                    {
     164                        blocks = (int)inputbytes / 8;
     165                    }
     166                    else
     167                    {
     168                        blocks = (int)Math.Round(inputbytes / 8 + 0.4, 0) + 1;
     169                    }
     170
     171                    byte[] inputbuffer = new byte[8 * blocks];
     172                    byte[] outputbuffer = new byte[4];
     173                    GuiLogMessage("# of blocks: " + blocks.ToString(), NotificationLevel.Debug);
     174
     175                    //read input
     176                    //GuiLogMessage("Current position: " + inputStream.Position.ToString(), NotificationLevel.Debug);
     177                    for (blocksRead = 0; blocksRead <= blocks - 1; blocksRead++)
     178                    {
     179                        for (position = bytesRead; position <= (blocksRead * 8 + 7); position++)
     180                        {
     181                            // no padding to do
     182                            if (position < inputbytes)
     183                            {
     184                                inputbuffer[position] = (byte)reader.ReadByte();
     185                            }
     186                            else // padding to do!
     187                            {
     188                                if (padding == 0)
     189                                {
     190                                    // padding with zeros
     191                                    inputbuffer[position] = 48;
     192                                }
     193                                else if (padding == 2)
     194                                {
     195                                    // padding with PKCS7
     196                                    int temp = 8 - (int)inputbytes % 8 + 48;
     197                                    inputbuffer[position] = (byte)temp;
     198                                }
     199                                else
     200                                {
     201                                    // no padding
     202                                    inputbuffer[position] = (byte)reader.ReadByte();
     203                                    GuiLogMessage("Byte is: " + inputbuffer[position].ToString(), NotificationLevel.Info);
     204                                }
     205                            }
     206                            bytesRead++;
     207                            //GuiLogMessage("Current position: " + inputStream.Position.ToString(), NotificationLevel.Debug);
     208                            //GuiLogMessage("Content of buffer[" + position + "]: " + buffer[position].ToString(), NotificationLevel.Debug);
     209                        }
     210                    }
     211
     212                    //GuiLogMessage("vector[0] before coding: " + vector[0].ToString(), NotificationLevel.Debug);
     213                    //GuiLogMessage("vector[1] before coding: " + vector[1].ToString(), NotificationLevel.Debug);
     214
     215                    uint[] key = new uint[4];
     216                    long[] longKey = new long[4];
     217                    long keybytes = inputKey.Length;
     218                    GuiLogMessage("inputKey length [byte]: " + keybytes.ToString(), NotificationLevel.Debug);
     219
     220                    if (keybytes != 16)
     221                    {
     222                        GuiLogMessage("Given key has false length. Please provide a key with 128 Bits length. Aborting now.", NotificationLevel.Error);
     223                        return;
     224                    }
     225                    else
     226                    {
     227                        if (settings.Version != 2)
     228                        {
     229                            key[0] = BitConverter.ToUInt32(inputKey, 0);
     230                            key[1] = BitConverter.ToUInt32(inputKey, 4);
     231                            key[2] = BitConverter.ToUInt32(inputKey, 8);
     232                            key[3] = BitConverter.ToUInt32(inputKey, 12);
     233                        }
     234                        else
     235                        {
     236                            longKey[0] = (long)BitConverter.ToUInt32(inputKey, 0);
     237                            longKey[1] = (long)BitConverter.ToUInt32(inputKey, 4);
     238                            longKey[2] = (long)BitConverter.ToUInt32(inputKey, 8);
     239                            longKey[3] = (long)BitConverter.ToUInt32(inputKey, 12);
     240                        }
     241                    }
     242
     243                    //encryption or decryption
     244                    //GuiLogMessage("Action is: " + action, NotificationLevel.Debug);
     245                    DateTime startTime = DateTime.Now;
     246
     247                    uint[] vector = new uint[2];
     248                    long[] longVector = new long[2];
     249
     250                    if (action == 0)
     251                    {
     252                        GuiLogMessage("Starting encryption [Keysize=128 Bits, Blocksize=64 Bits]", NotificationLevel.Info);
     253                        for (int i = 0; i <= blocks - 1; i++)
     254                        {
     255                            vector[0] = BitConverter.ToUInt32(inputbuffer, (i * 8));
     256                            vector[1] = BitConverter.ToUInt32(inputbuffer, (i * 8 + 4));
     257
     258                            // see in settings which version of TEA to use
     259                            if (settings.Version == 0)
     260                            {
     261                                encode_tea(vector, key);
     262                                StatusChanged((int)TEAImage.Encode);
     263                            }
     264                            else if (settings.Version == 1)
     265                            {
     266                                encode_xtea((uint)settings.Rounds, vector, key);
     267                                StatusChanged((int)TEAImage.EncodeX);
     268                            }
     269                            else if (settings.Version == 2)
     270                            {
     271                                btea(vector, 2, key);
     272                                StatusChanged((int)TEAImage.EncodeX);
     273                            }
     274
     275                            //write buffer to output stream
     276                            outputbuffer = BitConverter.GetBytes(vector[0]);
     277                            outputStream.Write(outputbuffer, 0, 4);
     278                            outputbuffer = BitConverter.GetBytes(vector[1]);
     279                            outputStream.Write(outputbuffer, 0, 4);
     280                        }
     281                    }
     282                    else if (action == 1)
     283                    {
     284                        GuiLogMessage("Starting decryption [Keysize=128 Bits, Blocksize=64 Bits]", NotificationLevel.Info);
     285                        for (int i = 0; i <= blocks - 1; i++)
     286                        {
     287                            vector[0] = BitConverter.ToUInt32(inputbuffer, i * 8);
     288                            vector[1] = BitConverter.ToUInt32(inputbuffer, i * 8 + 4);
     289
     290                            // see in settings which version of TEA to use
     291                            if (settings.Version == 0)
     292                            {
     293                                decode_tea(vector, key);
     294                                StatusChanged((int)TEAImage.Decode);
     295                            }
     296                            else if (settings.Version == 1)
     297                            {
     298                                decode_xtea((uint)settings.Rounds, vector, key);
     299                                StatusChanged((int)TEAImage.DecodeX);
     300                            }
     301                            else if (settings.Version == 2)
     302                            {
     303                                btea(vector, -2, key);
     304                                StatusChanged((int)TEAImage.DecodeX);
     305                            }
     306
     307                            //write buffer to output stream
     308                            outputbuffer = BitConverter.GetBytes(vector[0]);
     309                            outputStream.Write(outputbuffer, 0, 4);
     310                            outputbuffer = BitConverter.GetBytes(vector[1]);
     311                            outputStream.Write(outputbuffer, 0, 4);
     312                        }
     313                    }
     314
     315                    //GuiLogMessage("vector[0] after coding: " + vector[0], NotificationLevel.Debug);
     316                    //GuiLogMessage("vector[1] after coding: " + vector[1], NotificationLevel.Debug);
     317
     318                    /*while ((bytesRead = inputStream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
     319                    {
     320                        outputStream.Write(buffer, 0, bytesRead);
     321                        if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     322                        {
     323                            position = (int)(inputStream.Position * 100 / inputStream.Length);
     324                            //ProgressChanged(inputStream.Position, inputStream.Length);
     325                        }
     326                    }*/
     327
     328                    long outbytes = outputStream.Length;
     329                    DateTime stopTime = DateTime.Now;
     330                    TimeSpan duration = stopTime - startTime;
     331
     332                    if (!stop)
     333                    {
     334                        if (action == 0)
     335                        {
     336                            GuiLogMessage("Encryption complete! (in: " + inputbytes + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
     337                        }
     338                        else
     339                        {
     340                            GuiLogMessage("Decryption complete! (in: " + inputbytes + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
     341                        }
     342                        GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
     343                        outputStream.Close();
     344                        OnPropertyChanged("OutputStream");
     345                    }
     346
     347                    if (stop)
     348                    {
     349                        outputStream.Close();
     350                        GuiLogMessage("Aborted!", NotificationLevel.Info);
     351                    }
    166352                }
    167                 else
    168                 {
    169                     blocks = (int)Math.Round(inputbytes / 8 + 0.4, 0) + 1;
    170                 }
    171 
    172                 byte[] inputbuffer = new byte[8 * blocks];
    173                 byte[] outputbuffer = new byte[4];
    174                 GuiLogMessage("# of blocks: " + blocks.ToString(), NotificationLevel.Debug);
    175 
    176                 //read input
    177                 //GuiLogMessage("Current position: " + inputStream.Position.ToString(), NotificationLevel.Debug);
    178                 for (blocksRead = 0; blocksRead <= blocks - 1; blocksRead++)
    179                 {
    180                     for (position = bytesRead; position <= (blocksRead * 8 + 7); position++)
    181                     {
    182                         // no padding to do
    183                         if (position < inputbytes)
    184                         {
    185                                 inputbuffer[position] = (byte)reader.ReadByte();
    186                         }
    187                         else // padding to do!
    188                         {
    189                             if (padding == 0)
    190                             {
    191                                 // padding with zeros
    192                                 inputbuffer[position] = 48;
    193                             }
    194                             else if (padding == 2)
    195                             {
    196                                 // padding with PKCS7
    197                                 int temp = 8 - (int)inputbytes % 8 + 48;
    198                                 inputbuffer[position] = (byte)temp;
    199                             }
    200                             else
    201                             {
    202                                 // no padding
    203                                     inputbuffer[position] = (byte)reader.ReadByte();
    204                                 GuiLogMessage("Byte is: " + inputbuffer[position].ToString(), NotificationLevel.Info);
    205                             }
    206                         }
    207                         bytesRead++;
    208                         //GuiLogMessage("Current position: " + inputStream.Position.ToString(), NotificationLevel.Debug);
    209                         //GuiLogMessage("Content of buffer[" + position + "]: " + buffer[position].ToString(), NotificationLevel.Debug);
    210                     }
    211                 }
    212 
    213                 //GuiLogMessage("vector[0] before coding: " + vector[0].ToString(), NotificationLevel.Debug);
    214                 //GuiLogMessage("vector[1] before coding: " + vector[1].ToString(), NotificationLevel.Debug);
    215 
    216                 uint[] key = new uint[4];
    217                 long[] longKey = new long[4];
    218                 long keybytes = inputKey.Length;
    219                 GuiLogMessage("inputKey length [byte]: " + keybytes.ToString(), NotificationLevel.Debug);
    220 
    221                 if (keybytes != 16)
    222                 {
    223                     GuiLogMessage("Given key has false length. Please provide a key with 128 Bits length. Aborting now.", NotificationLevel.Error);
    224                     return;
    225                 }
    226                 else
    227                 {
    228                     if (settings.Version != 2)
    229                     {
    230                         key[0] = BitConverter.ToUInt32(inputKey, 0);
    231                         key[1] = BitConverter.ToUInt32(inputKey, 4);
    232                         key[2] = BitConverter.ToUInt32(inputKey, 8);
    233                         key[3] = BitConverter.ToUInt32(inputKey, 12);
    234                     }
    235                     else
    236                     {
    237                         longKey[0] = (long)BitConverter.ToUInt32(inputKey, 0);
    238                         longKey[1] = (long)BitConverter.ToUInt32(inputKey, 4);
    239                         longKey[2] = (long)BitConverter.ToUInt32(inputKey, 8);
    240                         longKey[3] = (long)BitConverter.ToUInt32(inputKey, 12);
    241                     }
    242                 }
    243 
    244                 //encryption or decryption
    245                 //GuiLogMessage("Action is: " + action, NotificationLevel.Debug);
    246                 DateTime startTime = DateTime.Now;
    247                
    248                 uint[] vector = new uint[2];
    249                 long[] longVector = new long[2];
    250 
    251                 if (action == 0)
    252                 {
    253                     GuiLogMessage("Starting encryption [Keysize=128 Bits, Blocksize=64 Bits]", NotificationLevel.Info);
    254                     for (int i = 0; i <= blocks-1; i++)
    255                     {
    256                         vector[0] = BitConverter.ToUInt32(inputbuffer, (i * 8));
    257                         vector[1] = BitConverter.ToUInt32(inputbuffer, (i * 8 + 4));
    258 
    259                         // see in settings which version of TEA to use
    260                         if (settings.Version == 0)
    261                         {
    262                             encode_tea(vector, key);
    263                             StatusChanged((int)TEAImage.Encode);
    264                         }
    265                         else if (settings.Version == 1)
    266                         {
    267                             encode_xtea((uint)settings.Rounds, vector, key);
    268                             StatusChanged((int)TEAImage.EncodeX);
    269                         }
    270                         else if (settings.Version == 2)
    271                         {
    272                             btea(vector, 2, key);
    273                             StatusChanged((int)TEAImage.EncodeX);
    274                         }
    275 
    276                         //write buffer to output stream
    277                         outputbuffer = BitConverter.GetBytes(vector[0]);
    278                         outputStream.Write(outputbuffer, 0, 4);
    279                         outputbuffer = BitConverter.GetBytes(vector[1]);
    280                         outputStream.Write(outputbuffer, 0, 4);
    281                     }
    282                     }
    283                     else if (action == 1)
    284                     {
    285                     GuiLogMessage("Starting decryption [Keysize=128 Bits, Blocksize=64 Bits]", NotificationLevel.Info);
    286                     for (int i = 0; i <= blocks-1; i++)
    287                     {
    288                         vector[0] = BitConverter.ToUInt32(inputbuffer, i * 8);
    289                         vector[1] = BitConverter.ToUInt32(inputbuffer, i * 8 + 4);
    290 
    291                         // see in settings which version of TEA to use
    292                         if (settings.Version == 0)
    293                         {
    294                             decode_tea(vector, key);
    295                             StatusChanged((int)TEAImage.Decode);
    296                         }
    297                         else if (settings.Version == 1)
    298                         {
    299                             decode_xtea((uint)settings.Rounds, vector, key);
    300                             StatusChanged((int)TEAImage.DecodeX);
    301                         }
    302                         else if (settings.Version == 2)
    303                         {
    304                             btea(vector, -2, key);
    305                             StatusChanged((int)TEAImage.DecodeX);
    306                         }
    307 
    308                         //write buffer to output stream
    309                         outputbuffer = BitConverter.GetBytes(vector[0]);
    310                         outputStream.Write(outputbuffer, 0, 4);
    311                         outputbuffer = BitConverter.GetBytes(vector[1]);
    312                         outputStream.Write(outputbuffer, 0, 4);
    313                     }
    314                 }
    315 
    316                 //GuiLogMessage("vector[0] after coding: " + vector[0], NotificationLevel.Debug);
    317                 //GuiLogMessage("vector[1] after coding: " + vector[1], NotificationLevel.Debug);
    318 
    319                 /*while ((bytesRead = inputStream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
    320                 {
    321                     outputStream.Write(buffer, 0, bytesRead);
    322                     if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
    323                     {
    324                         position = (int)(inputStream.Position * 100 / inputStream.Length);
    325                         //ProgressChanged(inputStream.Position, inputStream.Length);
    326                     }
    327                 }*/
    328 
    329                 long outbytes = outputStream.Length;
    330                 DateTime stopTime = DateTime.Now;
    331                 TimeSpan duration = stopTime - startTime;
    332 
    333                 if (!stop)
    334                 {
    335                     if (action == 0)
    336                     {
    337                             GuiLogMessage("Encryption complete! (in: " + inputbytes + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    338                     }
    339                     else
    340                     {
    341                             GuiLogMessage("Decryption complete! (in: " + inputbytes + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    342                     }
    343                     GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    344                     outputStream.Close();
    345                     OnPropertyChanged("OutputStream");
    346                 }
    347 
    348                 if (stop)
    349                 {
    350                     outputStream.Close();
    351                     GuiLogMessage("Aborted!", NotificationLevel.Info);
    352                 }
    353             }
    354353            }
    355354            catch (Exception exception)
     
    457456        }
    458457
    459         private uint btea(uint[] v, int n, uint[] k) {
     458        private uint btea(uint[] v, int n, uint[] k)
     459        {
    460460            int m = n;
    461461            if (n < -1) m = -n;
    462             uint z=v[m-1], y=v[0], sum=0, e, DELTA=0x9e3779b9;
    463            
     462            uint z = v[m - 1], y = v[0], sum = 0, e, DELTA = 0x9e3779b9;
     463
    464464            int p, q;
    465465
    466466            uint MX;
    467467
    468             if (n > 1) {          /* Coding Part */
    469               q = 6 + 52/n;
    470               while (q-- > 0) {
    471                 sum += DELTA;
    472                 e = (sum >> 2) & 3;
    473                 for (p=0; p<n-1; p++) {
    474                     y = v[p+1];
    475                     MX = (z>>5^y<<2) + (y>>3^z<<4)^(sum^y) + (k[p&3^e]^z);
    476                     z = v[p] += MX;
     468            if (n > 1)
     469            {          /* Coding Part */
     470                q = 6 + 52 / n;
     471                while (q-- > 0)
     472                {
     473                    sum += DELTA;
     474                    e = (sum >> 2) & 3;
     475                    for (p = 0; p < n - 1; p++)
     476                    {
     477                        y = v[p + 1];
     478                        MX = (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
     479                        z = v[p] += MX;
     480                    }
     481                    y = v[0];
     482                    GuiLogMessage("y: " + y.ToString("X"), NotificationLevel.Info);
     483                    MX = (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
     484                    z = v[n - 1] += MX;
     485                    GuiLogMessage("z: " + z.ToString("X"), NotificationLevel.Info);
    477486                }
    478                 y = v[0];
    479                 GuiLogMessage("y: " + y.ToString("X"), NotificationLevel.Info);
    480                 MX = (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
    481                 z = v[n-1] += MX;
    482                 GuiLogMessage("z: " + z.ToString("X"), NotificationLevel.Info);
    483               }
    484 
    485               GuiLogMessage("v[n-1]: " + v[n - 1].ToString("X"), NotificationLevel.Info);
    486               GuiLogMessage("v[0]: " + v[0].ToString("X"), NotificationLevel.Info);
    487 
    488               return 0 ;
    489             } else if (n < -1) {  /* Decoding Part */
    490               n = -n;
    491               q = 6 + 52/n;
    492               sum = (uint)q*DELTA ;
    493               while (sum != 0) {
    494                 e = (sum >> 2) & 3;
    495                 for (p = n - 1; p > 0; p--)
     487
     488                GuiLogMessage("v[n-1]: " + v[n - 1].ToString("X"), NotificationLevel.Info);
     489                GuiLogMessage("v[0]: " + v[0].ToString("X"), NotificationLevel.Info);
     490
     491                return 0;
     492            }
     493            else if (n < -1)
     494            {  /* Decoding Part */
     495                n = -n;
     496                q = 6 + 52 / n;
     497                sum = (uint)q * DELTA;
     498                while (sum != 0)
    496499                {
    497                     z = v[p - 1];
     500                    e = (sum >> 2) & 3;
     501                    for (p = n - 1; p > 0; p--)
     502                    {
     503                        z = v[p - 1];
     504                        MX = (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
     505                        y = v[p] -= MX;
     506                    }
     507                    z = v[n - 1];
    498508                    MX = (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
    499                     y = v[p] -= MX;
     509                    y = v[0] -= MX;
     510                    sum -= DELTA;
    500511                }
    501                 z = v[n - 1];
    502                 MX = (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
    503                 y = v[0] -= MX;
    504                 sum -= DELTA;
    505               }
    506               return 0;
     512                return 0;
    507513            }
    508514            return 1;
  • trunk/CrypPlugins/TextOutput/TextOutput.cs

    r2638 r2670  
    237237                using (CStreamReader reader = ((ICryptoolStream)value).CreateReader())
    238238                {
     239                    reader.WaitEof(); // does not support chunked streaming
     240
    239241                    // GuiLogMessage("Stream: Filling TextBoxes now...", NotificationLevel.Debug);
    240242                    if (reader.Length > settings.MaxLength)
  • trunk/CrypPlugins/WEP/WEP/WEP.cs

    r2529 r2670  
    556556                using (CStreamReader reader = inputStream.CreateReader())
    557557                {
     558                    reader.WaitEof(); // does not support chunked streaming
     559
    558560                    /// Checks if the input stream contains a valid value. If not, class waits for input AND DOES NOTHING.
    559561                    /// XXX: Execute() does not stop. Bug?
  • trunk/CrypPlugins/WEPAttacks/WEPAttacks/WEPAttacks.cs

    r2529 r2670  
    13941394                using (CStreamReader reader = inputStream.CreateReader())
    13951395                {
     1396                    reader.WaitEof(); // does not support chunked streaming
     1397
    13961398                    tempList = loadList(reader);
    13971399
Note: See TracChangeset for help on using the changeset viewer.