Changeset 2529


Ignore:
Timestamp:
Jan 30, 2011, 7:01:47 PM (11 years ago)
Author:
Matthäus Wander
Message:

Finally deploying CStreams.

  • The old CryptoolStream class is now obsolete, please see Wiki for more information.
  • This change may break some plugins. Please let me know if there are any problems or file a ticket.
Location:
trunk
Files:
1 deleted
70 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/CrypPluginBase/CrypPluginBase.csproj

    r2337 r2529  
    9393    <Compile Include="Control\IControlEncryption.cs" />
    9494    <Compile Include="Control\KeyTranslator.cs" />
    95     <Compile Include="IO\CStream.cs" />
    9695    <Compile Include="IO\CStreamReader.cs" />
    9796    <Compile Include="IO\CStreamWriter.cs" />
    9897    <Compile Include="IO\DirectoryHelper.cs" />
     98    <Compile Include="IO\ICryptoolStream.cs" />
    9999    <Compile Include="Miscellaneous\BigIntegerHelper.cs" />
    100100    <Compile Include="Miscellaneous\AssemblyHelper.cs" />
  • trunk/CrypPluginBase/IO/CStreamReader.cs

    r1131 r2529  
    6363                swapHandler();
    6464            }
    65 
    66             CStream = _writer.CStream;
    6765        }
    6866
     
    7169        #region Public properties
    7270
    73         public CStream CStream
    74         {
    75             get;
    76             private set;
    77         }
    78 
    7971        public override bool CanRead
    8072        {
    81             get { return true; }
     73            get { return !_disposed; }
    8274        }
    8375
    8476        public override bool CanSeek
    8577        {
    86             get { return true; }
     78            get { return !_disposed; }
    8779        }
    8880
  • trunk/CrypPluginBase/IO/CStreamWriter.cs

    r1131 r2529  
    3939    /// <para>You SHOULD Dispose() the stream when you're done using it (or use the C# "using" keyword) in
    4040    /// order to remove the temporary swapfile, however if you forget to, the GC will clean up for you.</para>
    41     /// </public>
    42     public class CStreamWriter : Stream, IDisposable
     41    /// </summary>
     42    public class CStreamWriter : Stream, IDisposable, ICryptoolStream
    4343    {
    44         #region Private fields and constructors
     44        #region Fields and constructors
     45
     46        public static readonly CStreamWriter Empty;
     47        static CStreamWriter()
     48        {
     49            // This is a somewhat ugly way to create an empty CStream -- using the Null Object
     50            // pattern (see GOF) would look better. However it is the easiest workaround.
     51            CStreamWriter.Empty = new CStreamWriter(0);
     52            CStreamWriter.Empty.Close();
     53        }
    4554
    4655        internal const int FileBufferSize = 8192;
     
    7281            _buffer = new byte[bufSize];
    7382            _monitor = new object();
    74 
    75             CStream = new CStream(this);
    7683        }
    7784
    7885        /// <summary>
    7986        /// Init CStreamWriter and copy some data to memory buffer.
    80         ///
    81         /// Please note: Data is *copied* from passed buffer to internal memory buffer.
     87        /// Data is *copied* from passed buffer to internal memory buffer.
     88        /// Stream is auto-closed after initialization (can't write any more data).
    8289        /// </summary>
    8390        /// <param name="buf">Pre-initialized byte array which is copied into internal membuff</param>
    84         /// <param name="autoClose">close after initialization</param>
    85         public CStreamWriter(byte[] buf, bool autoClose) : this(buf.Length)
    86         {
     91        public CStreamWriter(byte[] buf) : this((buf == null) ? 0 : buf.Length)
     92        {
     93            if (buf != null)
     94            {
    8795            Array.Copy(buf, _buffer, buf.Length);
    8896            _bufPtr = buf.Length;
    89 
    90             if (autoClose)
    91             {
     97            }
     98            Close();
     99        }
     100
     101        /// <summary>
     102        /// Init CStreamWriter with an existing file.
     103        /// Though the file is not modified we acquire a write lock to ensure it does not change while
     104        /// readers are accessing it.
     105        /// Will throw exception if IO goes wrong.
     106        /// Stream is auto-closed after initialization (can't write any more data).
     107        /// </summary>
     108        /// <param name="filePath">Path to existing file, already filled with data</param>
     109        public CStreamWriter(string filePath) : this(0)
     110            {
     111            if (!File.Exists(filePath))
     112            {
     113                throw new FileNotFoundException();
     114            }
     115
     116            // attempt to get exclusive write lock
     117            _filePath = filePath;
     118            _writeStream = new FileStream(_filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
     119            _writeStream.Seek(_writeStream.Length, SeekOrigin.Begin);
    92120                Close();
    93             }
    94         }
     121
     122            if (SwapEvent != null)
     123                SwapEvent();
     124            }
    95125
    96126        #endregion
     
    98128        #region Public properties
    99129
    100         public CStream CStream
    101         {
    102             get;
    103             private set;
    104         }
    105 
    106130        public override bool CanRead
    107131        {
     
    116140        public override bool CanWrite
    117141        {
    118             get { return true; }
     142            get { return !_closed; }
    119143        }
    120144
     
    335359        }
    336360
     361        /// <summary>
     362        /// Create a new instance to read from this CStream.
     363        /// </summary>
     364        public CStreamReader CreateReader()
     365        {
     366            return new CStreamReader(this);
     367        }
     368
     369        /// <summary>
     370        /// Attempts to read 4096 bytes from CStream, interpreted as string using default encoding.
     371        /// May return less if CStream doesn't contain that many bytes.
     372        /// </summary>
     373        public override string ToString()
     374        {
     375            using (CStreamReader reader = CreateReader())
     376            {
     377                byte[] buf = new byte[4096];
     378                int read = reader.Read(buf);
     379
     380                return Encoding.Default.GetString(buf, 0, read);
     381            }
     382        }
     383
    337384        #endregion
    338385
  • trunk/CrypPluginBase/IO/CryptoolStream.cs

    r1157 r2529  
    2020namespace Cryptool.PluginBase.IO
    2121{
     22    [Obsolete("Use ICryptoolStream, CStreamWriter and CStreamReader instead")]
    2223    public class CryptoolStream : Stream
    2324    {
     
    132133        /// <param name="Plugin"></param>
    133134        /// <param name="Bytes"></param>
     135        [Obsolete("Use ICryptoolStream, CStreamWriter and CStreamReader instead")]
    134136        public void OpenRead(byte[] Bytes)
    135137        {
     
    153155        }
    154156
    155         [Obsolete("pluginCaption is not used anymore, use OpenRead(byte[]) instead")]
     157        [Obsolete("Use ICryptoolStream, CStreamWriter and CStreamReader instead")]
    156158        public void OpenRead(string pluginCaption, byte[] Bytes)
    157159        {
     
    159161        }
    160162
     163        [Obsolete("Use ICryptoolStream, CStreamWriter and CStreamReader instead")]
    161164        public void OpenRead(string fileName)
    162165        {
     
    190193
    191194        # region write
    192         [Obsolete("pluginCaption is not used anymore, use OpenWrite() instead")]
     195        [Obsolete("Use ICryptoolStream, CStreamWriter and CStreamReader instead")]
    193196        public void OpenWrite(string pluginCaption)
    194197        {
     
    196199        }
    197200
     201        [Obsolete("Use ICryptoolStream, CStreamWriter and CStreamReader instead")]
    198202        public void OpenWrite()
    199203        {
  • trunk/CrypPluginBase/IO/DirectoryHelper.cs

    r1736 r2529  
    9595            } while (File.Exists(filePath)); // sanity check for GUID collision
    9696
     97            // ensure the temp directory exists
     98            if (!Directory.Exists(DirectoryHelper.DirectoryLocalTemp))
     99            {
     100                Directory.CreateDirectory(DirectoryHelper.DirectoryLocalTemp);
     101            }
     102
    97103            return filePath;
    98104        }
  • trunk/CrypPlugins/ADFGVX/ADFGVX.cs

    r2334 r2529  
    4141        private string inputString;
    4242        private string outputString;
    43         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4443       
    4544        #endregion
     
    6665
    6766        [PropertyInfo(Direction.OutputData, "Stream output", "The string after processing with the Caesar cipher is converted to a stream. Default encoding is used.", "", false, false, QuickWatchFormat.Text, null)]
    68         public CryptoolStream OutputData
     67        public ICryptoolStream OutputData
    6968        {
    7069            get
     
    7271                if (outputString != null)
    7372                {
    74                     CryptoolStream cs = new CryptoolStream();
    75                     listCryptoolStreamsOut.Add(cs);
    76                     cs.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(outputString.ToCharArray()));
    77                     return cs;
     73                    return new CStreamWriter(Encoding.Default.GetBytes(outputString));
    7874                }
    7975                else
     
    512508        public void Dispose()
    513509        {
    514             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    515             {
    516                 stream.Close();
    517             }
    518             listCryptoolStreamsOut.Clear();
    519         }
     510            }
    520511
    521512        public bool HasChanges
  • trunk/CrypPlugins/AES/AES.cs

    r2334 r2529  
    1 /*
     1/*
    22   Copyright 2008 Dr. Arno Wacker, University of Duisburg-Essen
    33
     
    4242        #region Private variables
    4343        private AESSettings settings;
    44         private CryptoolStream inputStream;
    45         private CryptoolStream outputStream;
     44        private CStreamWriter outputStreamWriter;
    4645        private byte[] inputKey;
    4746        private byte[] inputIV;
    4847        private CryptoStream p_crypto_stream;
    4948        private bool stop = false;
    50         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    5149        #endregion
    5250
     
    6967
    7068        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", "", true, false, QuickWatchFormat.Hex, null)]
    71         public CryptoolStream InputStream
    72         {
    73             get
    74             {
    75               if (inputStream != null)
    76               {
    77                 CryptoolStream cs = new CryptoolStream();
    78                 cs.OpenRead(inputStream.FileName);
    79                 listCryptoolStreamsOut.Add(cs);
    80                 return cs;
     69        public ICryptoolStream InputStream
     70        {
     71            get;
     72            set;
    8173              }
    82               else return null;
    83             }
    84             set
    85             {
    86               this.inputStream = value;
    87               if (value != null) listCryptoolStreamsOut.Add(value);
    88               OnPropertyChanged("InputStream");
    89             }
    90         }
    9174
    9275        [PropertyInfo(Direction.InputData, "Key", "The provided key should be 16, 24 or 32 bytes, dependig on the settings. Too short/long keys will be extended/truncated!", "", true, false, QuickWatchFormat.Hex, null)]
     
    11396
    11497        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", "", true, false, QuickWatchFormat.Hex, null)]
    115         public CryptoolStream OutputStream
     98        public ICryptoolStream OutputStream
    11699        {
    117100            get
    118101            {
    119               if (this.outputStream != null)
    120               {
    121                 CryptoolStream cs = new CryptoolStream();
    122                 listCryptoolStreamsOut.Add(cs);
    123 
    124                   if (outputStream.FileName == null)
    125                   {
    126                       return null;
     102                return outputStreamWriter;
    127103                  }
    128 
    129                   try
    130                   {
    131                       cs.OpenRead(this.outputStream.FileName);
    132                   }
    133                   catch (FileNotFoundException)
    134                   {
    135                       GuiLogMessage("File not found: " + outputStream.FileName, NotificationLevel.Warning);
    136                       return null;
    137                   }
    138 
    139                   return cs;
    140               }
    141               return null;
    142             }
    143104            set
    144105            {
    145               outputStream = value;
    146               if (value != null) listCryptoolStreamsOut.Add(value);
    147               OnPropertyChanged("OutputStream");
     106                // empty
    148107            }
    149108        }
     
    232191        private void checkForInputStream()
    233192        {
    234             if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
     193            if (settings.Action == 0 && (InputStream == null || InputStream.Length == 0))
    235194            {
    236195                //create some input
    237196                String dummystring = "Dummy string - no input provided - \"Hello AES World\" - dummy string - no input provided!";
    238                 this.inputStream = new CryptoolStream();
    239                 this.inputStream.OpenRead(Encoding.Default.GetBytes(dummystring.ToCharArray()));
     197                this.InputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring.ToCharArray()));
    240198                // write a warning to the ouside word
    241199                GuiLogMessage("WARNING: No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     
    260218          {
    261219            checkForInputStream();
    262             if (inputStream == null || inputStream.Length == 0)
     220                if (InputStream == null || InputStream.Length == 0)
    263221            {
    264222              GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    266224            }
    267225
    268             if (this.inputStream.CanSeek) this.inputStream.Position = 0;
    269226            SymmetricAlgorithm p_alg = null;
    270227            if (settings.CryptoAlgorithm == 1)
     
    286243            }
    287244
    288             outputStream = new CryptoolStream();
    289             listCryptoolStreamsOut.Add(outputStream);
    290             outputStream.OpenWrite();
    291             p_crypto_stream = new CryptoStream((Stream)inputStream, p_encryptor, CryptoStreamMode.Read);
     245                outputStreamWriter = new CStreamWriter();
     246                using (CStreamReader reader = InputStream.CreateReader())
     247                {
     248                    p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read);
    292249            byte[] buffer = new byte[p_alg.BlockSize / 8];
    293250            int bytesRead;
     
    298255            while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
    299256            {
    300               outputStream.Write(buffer, 0, bytesRead);
    301 
    302               if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     257                        outputStreamWriter.Write(buffer, 0, bytesRead);
     258
     259                        if ((int)(reader.Position * 100 / reader.Length) > position)
    303260              {
    304                 position = (int)(inputStream.Position * 100 / inputStream.Length);
    305                 ProgressChanged(inputStream.Position, inputStream.Length);
     261                            position = (int)(reader.Position * 100 / reader.Length);
     262                            ProgressChanged(reader.Position, reader.Length);
    306263              }
    307264            }
    308265
    309266
    310             long outbytes = outputStream.Length;
     267                    long outbytes = outputStreamWriter.Length;
    311268            p_crypto_stream.Flush();           
    312269            // p_crypto_stream.Close();
     
    318275            {
    319276                mode = action == 0 ? "Encryption" : "Decryption";
    320                 GuiLogMessage(mode + " complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    321                 GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
     277                        GuiLogMessage(mode + " complete! (in: " + reader.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    322278                GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    323                 outputStream.Close();
     279                        outputStreamWriter.Close();
    324280                OnPropertyChanged("OutputStream");
    325281            }
    326             CryptoolStream test = outputStream;
    327282            if (stop)
    328283            {
    329                 outputStream.Close();
     284                        outputStreamWriter.Close();
    330285                GuiLogMessage("Aborted!", NotificationLevel.Info);
    331286            }
    332287          }
     288            }
    333289          catch (CryptographicException cryptographicException)
    334290          {
     
    386342            inputKey = null;
    387343            inputIV = null;
    388             outputStream = null;
    389             inputStream = null;
    390 
    391             //if (inputStream != null)
    392             //{
    393             //  inputStream.Flush();
    394             //  inputStream.Close();
    395             //  inputStream = null;
    396             //}
    397             //if (outputStream != null)
    398             //{
    399             //  outputStream.Flush();
    400             //  outputStream.Close();
    401             //  outputStream = null;
    402             //}
    403             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    404             {
    405               stream.Close();
    406             }
    407             listCryptoolStreamsOut.Clear();
     344
     345                if (outputStreamWriter != null)
     346            {
     347                    outputStreamWriter.Dispose();
     348                    outputStreamWriter = null;
     349            }
    408350
    409351            if (p_crypto_stream != null)
  • trunk/CrypPlugins/CRC/CRC.cs

    r2334 r2529  
    11/*
    2    Copyright 2009 Matthäus Wander, University of Duisburg-Essen
     2   Copyright 2009-2010 Matthäus Wander, University of Duisburg-Essen
    33
    44   Licensed under the Apache License, Version 2.0 (the "License");
     
    6666
    6767        private ISettings settings = new CRCSettings();
    68         private CryptoolStream inputData;
    69         private byte[] outputData;
    70         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     68        private CStreamWriter outputStreamWriter;
    7169
    7270        private uint[] table;
     
    8785
    8886        [PropertyInfo(Direction.InputData, "Input stream", "Input data to be hashed", "", true, false, QuickWatchFormat.Hex, null)]
    89         public CryptoolStream InputData
     87        public ICryptoolStream InputStream
     88        {
     89            get;
     90            set;
     91            }
     92
     93        [PropertyInfo(Direction.OutputData, "Hash value", "Output hash value as Stream", "", false, false, QuickWatchFormat.Hex, null)]
     94        public ICryptoolStream OutputStream
    9095        {
    9196            get
    9297            {
    93                 if (inputData == null) { return null; }
    94 
    95                 GuiLogMessage("Filename of input stream: " + inputData.FileName, NotificationLevel.Debug);
    96 
    97                 CryptoolStream cs = new CryptoolStream();
    98                 cs.OpenRead(inputData.FileName);
    99                 listCryptoolStreamsOut.Add(cs);
    100                 return cs;
    101             }
     98                return outputStreamWriter;
     99            }
     100
    102101            set
    103102            {
    104                 inputData = value;
    105                 OnPropertyChanged("InputData");
    106             }
    107         }
    108 
    109         [PropertyInfo(Direction.OutputData, "Hash value", "Output hash value as byte array", "", false, false, QuickWatchFormat.Hex, null)]
    110         public byte[] OutputData
    111         {
    112             get
    113             {
    114                 if (outputData == null) { return null; }
    115 
    116                 GuiLogMessage("Got request for hash (byte array)", NotificationLevel.Debug);
    117                 return outputData;
    118             }
    119             set
    120             {
    121             }
    122         }
    123 
    124         [PropertyInfo(Direction.OutputData, "Hash value", "Output hash value as Stream", "", false, false, QuickWatchFormat.Hex, null)]
    125         public CryptoolStream OutputDataStream
    126         {
    127             get
    128             {
    129                 if (outputData == null) { return null; }
    130 
    131                 CryptoolStream cs = new CryptoolStream();
    132                 listCryptoolStreamsOut.Add(cs);
    133                 cs.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    134                 GuiLogMessage("Got request for hash (stream)", NotificationLevel.Debug);
    135                 return cs;
    136             }
    137             set
    138             {
    139103            }
    140104        }
     
    146110        public void Dispose()
    147111        {
    148             if (inputData != null)
    149             {
    150                 inputData.Close();
    151                 inputData = null;
    152             }
    153 
    154             foreach (CryptoolStream cs in listCryptoolStreamsOut)
    155             {
    156                 cs.Close();
    157             }
    158         }
     112            if (outputStreamWriter != null)
     113            {
     114                outputStreamWriter.Dispose();
     115                outputStreamWriter = null;
     116            }
     117            }
    159118
    160119        public void Execute()
     
    162121            ProgressChanged(0.0, 1.0);
    163122
    164             if (inputData == null)
    165             {
    166                 GuiLogMessage("Received null value for input CryptoolStream, not processing.", NotificationLevel.Warning);
     123            if (InputStream == null)
     124            {
     125                GuiLogMessage("Received null value for input CStream, not processing.", NotificationLevel.Warning);
    167126                return;
    168127            }
     
    170129            byte[] input = new byte[BUFSIZE];
    171130            uint crc = 0xffffffff;
    172             int readCount;
    173 
    174             // read and process 1024 bytes long portions of input stream
    175             for(long bytesLeft = inputData.Length - inputData.Position; inputData.Position < inputData.Length; bytesLeft -= readCount)
    176             {
    177                 ProgressChanged((double)inputData.Position / inputData.Length, 1.0);
    178                 readCount = bytesLeft < input.Length ? (int)bytesLeft : input.Length;
    179                 GuiLogMessage("Trying to fill working buffer with " + readCount + " bytes", NotificationLevel.Debug);
    180                 readCount = inputData.Read(input, 0, readCount);
    181 
     131
     132            using (CStreamReader reader = InputStream.CreateReader())
     133            {
     134                // read and process portions of up to BUFSIZE bytes of input stream
     135                int readCount;
     136                while ((readCount = reader.Read(input)) > 0)
     137                {
    182138                for (int i = 0; i < readCount; ++i)
    183139                {
     
    185141                    crc = (uint)((crc >> 8) ^ table[index]);
    186142                }
     143
     144                    ProgressChanged((double)reader.Position / reader.Length, 1.0);
     145            }
    187146            }
    188147
    189148            crc ^= 0xffffffff;
    190149
    191             outputData = new byte[4];
     150            byte[] outputData = new byte[4];
    192151
    193152            outputData[0] = (byte)(crc >> 24);
     
    196155            outputData[3] = (byte)(crc);
    197156
     157            // create new one
     158            outputStreamWriter = new CStreamWriter(outputData);
     159
    198160            ProgressChanged(1.0, 1.0);
    199             GuiLogMessage("CRC calculation has finished", NotificationLevel.Debug);
    200 
    201             OnPropertyChanged("OutputData");
    202             OnPropertyChanged("OutputDataStream");
     161            OnPropertyChanged("OutputStream");
    203162        }
    204163
     
    237196        public void PostExecution()
    238197        {
    239             Dispose();
    240198        }
    241199
  • trunk/CrypPlugins/Caesar/Caesar.cs

    r2385 r2529  
    3636
    3737        private CaesarSettings settings;
    38         // private CryptoolStream outputData;
    3938        private string inputString;
    4039        private string outputString;
    4140        private enum CaesarMode { encrypt, decrypt };
    42         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4341        private bool isPlayMode = false;
    4442        #endregion
     
    6765
    6866        [PropertyInfo(Direction.OutputData, "propStreamOutputToolTip", "propStreamOutputDescription", "", false, false, QuickWatchFormat.Text, null)]
    69         public CryptoolStream OutputData
     67        public ICryptoolStream OutputData
    7068        {
    7169            get
     
    7371                if (outputString != null)
    7472                {                   
    75                     CryptoolStream cs = new CryptoolStream();
    76                     listCryptoolStreamsOut.Add(cs);
    77                     cs.OpenRead(Encoding.Default.GetBytes(outputString.ToCharArray()));
    78                     return cs;
     73                    return new CStreamWriter(Encoding.Default.GetBytes(outputString));
    7974                }
    8075                else
     
    168163        public void Dispose()
    169164        {
    170           foreach (CryptoolStream stream in listCryptoolStreamsOut)
    171           {
    172             stream.Close();
    173165          }
    174           listCryptoolStreamsOut.Clear();
    175         }
    176166
    177167        public bool HasChanges
  • trunk/CrypPlugins/ClipboardInput/ClipboardInput.cs

    r2334 r2529  
    3535
    3636    #region Private Variables
    37     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    38     // private CryptoolStream clipboard;
    3937    private ClipboardInputSettings settings;
    4038
     
    7977    #region Interface
    8078    [PropertyInfo(Direction.OutputData, "Clipboard data stream", "Stream of data recieved from clipboard", "", true, false, QuickWatchFormat.Text, null)]
    81     public CryptoolStream StreamOutput
     79    public ICryptoolStream StreamOutput
    8280    {
    8381      get
     
    9189        if (Data != null && Data != string.Empty)
    9290        {
    93           CryptoolStream cryptoolStream = null;
     91            ICryptoolStream cryptoolStream = null;
    9492          switch (settings.Format)
    9593          { //0="Text", 1="Hex", 2="Base64"
     
    108106          }
    109107          Progress(1.0, 1.0);
    110           listCryptoolStreamsOut.Add(cryptoolStream);
    111108          return cryptoolStream;
    112109        }
     
    123120    #endregion
    124121
    125     private CryptoolStream Text2Stream(string data)
    126     {
    127       CryptoolStream cs = new CryptoolStream();
    128       cs.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(data.ToCharArray()));
    129       return cs;
    130     }
    131 
    132     private CryptoolStream Base642Stream(string data)
     122    private ICryptoolStream Text2Stream(string data)
     123    {
     124        return new CStreamWriter(Encoding.Default.GetBytes(data));
     125    }
     126
     127    private ICryptoolStream Base642Stream(string data)
    133128    {
    134129      byte[] temp = new byte[0];
     
    141136        GuiLogMessage(exception.Message, NotificationLevel.Error);
    142137      }
    143       CryptoolStream cs = new CryptoolStream();
    144       cs.OpenRead(this.GetPluginInfoAttribute().Caption, temp);
    145       return cs;     
    146     }
    147 
    148     private CryptoolStream Hex2Stream(string data)
    149     {
    150       CryptoolStream cs = new CryptoolStream();
    151       cs.OpenRead(this.GetPluginInfoAttribute().Caption, ToByteArray(data));
    152       return cs;
     138
     139        return new CStreamWriter(temp);
     140    }
     141
     142    private ICryptoolStream Hex2Stream(string data)
     143    {
     144        return new CStreamWriter(ToByteArray(data));
    153145    }
    154146
     
    194186    public void Dispose()
    195187    {
    196       foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    197       {
    198         cryptoolStream.Close();
    199       }
    200       listCryptoolStreamsOut.Clear();
    201     }
     188      }
    202189
    203190    public void Stop()
  • trunk/CrypPlugins/ClipboardOutput/ClipboardOutput.cs

    r2334 r2529  
    4040
    4141                #region Private Variables
    42     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4342                private ClipboardOutputSettings settings;
    4443               
     
    7574
    7675                #region Interface
    77     private CryptoolStream streamInput;
     76    private ICryptoolStream streamInput;
    7877    [PropertyInfo(Direction.InputData, "Stream", "Data to be copied to clipboard", "", true, false, QuickWatchFormat.Text, null)]
    79     public CryptoolStream StreamInput
     78    public ICryptoolStream StreamInput
    8079    {
    8180                        get
     
    8382        if (Data != null && Data != string.Empty)
    8483        {
    85           CryptoolStream cs = new CryptoolStream();
    86           listCryptoolStreamsOut.Add(cs);
    87           cs.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(Data.ToCharArray()));
    88          
    89           return cs;
     84            return new CStreamWriter(Encoding.Default.GetBytes(Data));
    9085        }
    9186        return null;
     
    9792        {
    9893          streamInput = value;
    99                                         switch (settings.Format) { //0="Text", 1="Hex", 2="Base64"
     94          switch (settings.Format)
     95          { //0="Text", 1="Hex", 2="Base64"
    10096                                                case 1:
    10197              Data = Stream2Hex(value);
     
    119115                                        GuiLogMessage("Wrote " + data.Length + " characters to clipboard", NotificationLevel.Info);
    120116          Progress(1.0, 1.0);
    121           value.Close();         
    122117                                }
    123118        else
     
    129124                }
    130125
    131     private string Stream2Text(CryptoolStream value)
    132     {
     126    private string Stream2Text(ICryptoolStream value)
     127    {
     128        using (CStreamReader reader = value.CreateReader())
     129        {
    133130                        int byteValue;
    134                         value.Seek(0, SeekOrigin.Begin);
    135131                        StringBuilder sb = new StringBuilder();
    136                         while ((byteValue = value.ReadByte()) != -1)
    137       {
     132            while ((byteValue = reader.ReadByte()) != -1)
     133      {
     134                // FIXME: UTF-8 characters may consist of more than a single byte
    138135                                sb.Append(System.Convert.ToChar(byteValue));
    139136                        }
    140137                        return sb.ToString();
    141138                }
    142 
    143     private string Stream2Base64(CryptoolStream value)
    144     {
    145                         byte[] byteValues = new byte[value.Length];
    146                         value.Seek(0, SeekOrigin.Begin);
    147                         value.Read(byteValues, 0, (int)value.Length);
     139    }
     140
     141    private string Stream2Base64(ICryptoolStream value)
     142    {
     143        using (CStreamReader reader = value.CreateReader())
     144        {
     145            byte[] byteValues = new byte[reader.Length];
     146            reader.Read(byteValues, 0, (int)reader.Length);
    148147                        return Convert.ToBase64String(byteValues);
    149148                }
    150 
    151     private string Stream2Hex(CryptoolStream value)
    152     {
     149    }
     150
     151    private string Stream2Hex(ICryptoolStream value)
     152    {
     153        using (CStreamReader reader = value.CreateReader())
     154        {
    153155                        int byteValue;
    154                         value.Seek(0, SeekOrigin.Begin);
    155156                        StringBuilder sb = new StringBuilder();
    156                         while ((byteValue = value.ReadByte()) != -1)
     157            while ((byteValue = reader.ReadByte()) != -1)
    157158      {
    158159                                sb.Append(byteValue.ToString("x2"));
     
    160161                        return sb.ToString();
    161162          }
     163    }
    162164
    163165                #endregion
     
    178180    }
    179181
    180                 public void Initialize() {
     182    public void Initialize()
     183    {
    181184                }
    182185
    183186                public void Dispose()
    184187    {
    185       foreach (CryptoolStream crytoolStream in listCryptoolStreamsOut)
    186       {
    187         crytoolStream.Close();
    188       }
    189       listCryptoolStreamsOut.Clear();
    190                 }
     188      }
    191189
    192190    public void Stop()
     
    202200    public void PostExecution()
    203201    {
    204       // if (Data != null && Data != string.Empty) OnPropertyChanged("Data");
    205       Dispose();
    206202    }
    207203
  • trunk/CrypPlugins/Collector/Collector.cs

    r2334 r2529  
    3434        #region Private Variables
    3535        private CollectorSettings settings = new CollectorSettings();
    36         private List<CryptoolStream> listCryptoolStreamOut = new List<CryptoolStream>();
    3736        private bool freshOutput = false;
    3837        #endregion
     
    8483            set
    8584            {
    86                 if (value is CryptoolStream)
    87                 {
    88                     CryptoolStream cs = new CryptoolStream();
    89                     cs.OpenRead((value as CryptoolStream).FileName);
    90                     listCryptoolStreamOut.Add(cs);
    91                     output = cs;
    92                 }
    93                 else
    9485                    output = value;
    9586            }
     
    175166        public void Dispose()
    176167        {
    177             foreach (CryptoolStream cs in listCryptoolStreamOut)
    178                 cs.Close();
    179168        }
    180169
  • trunk/CrypPlugins/Concatenate/Concatenate.cs

    r2334 r2529  
    3333  {
    3434    # region Fields
    35     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     35    private List<IDisposable> listCryptoolStreamsOut = new List<IDisposable>();
    3636    private readonly string inputOne = "InputOne";
    3737    private readonly string inputTwo = "InputTwo";
     
    9898      {
    9999        case ConcatenateSettings.DataTypes.CryptoolStream:
    100           return typeof(CryptoolStream);
     100          return typeof(ICryptoolStream);
    101101        case ConcatenateSettings.DataTypes.String:
    102102          return typeof(string);
     
    115115    {
    116116      Type type = getCurrentType();
    117       if (type == typeof(CryptoolStream))
     117      if (type == typeof(ICryptoolStream))
    118118        return QuickWatchFormat.Hex;
    119119      else if (type == typeof(string))
     
    151151        {
    152152          DicDynamicProperties[propertyKey].Value = value;
    153           if (value is CryptoolStream) listCryptoolStreamsOut.Add((CryptoolStream)value);
    154153          OnPropertyChanged(propertyKey);
    155154        }
     
    166165            #region CryptoolStream
    167166            case ConcatenateSettings.DataTypes.CryptoolStream:
    168               CryptoolStream stream1 = val1 as CryptoolStream;
    169               CryptoolStream stream2 = val2 as CryptoolStream;
    170               CryptoolStream returnStream = new CryptoolStream();
    171               returnStream.OpenWrite();
     167              CStreamReader stream1 = (val1 as ICryptoolStream).CreateReader();
     168              CStreamReader stream2 = (val2 as ICryptoolStream).CreateReader();
     169              CStreamWriter returnStream = new CStreamWriter();
    172170              byte[] byteValues = new byte[1024];
    173171              int byteRead;
     
    251249        {
    252250          DicDynamicProperties[propertyKey].Value = value;
    253           if (value is CryptoolStream)
    254             listCryptoolStreamsOut.Add((CryptoolStream)value);
    255251          OnPropertyChanged(propertyKey);
    256252        }
     
    269265        if (DicDynamicProperties.ContainsKey(propertyKey))
    270266        {
    271           if (DicDynamicProperties[propertyKey].Value is CryptoolStream)
    272           {
    273             CryptoolStream cryptoolStream = new CryptoolStream();
    274             cryptoolStream.OpenRead((DicDynamicProperties[propertyKey].Value as CryptoolStream).FileName);
    275             listCryptoolStreamsOut.Add(cryptoolStream);
    276             return cryptoolStream;
    277           }
    278267          return DicDynamicProperties[propertyKey].Value;
    279268        }
     
    321310    public void PreExecution()
    322311    {
    323       Dispose();
    324312    }
    325313
     
    330318    public void PostExecution()
    331319    {
    332       Dispose();
     320        DicDynamicProperties[inputOne].Value = null;
     321        DicDynamicProperties[inputTwo].Value = null;
     322        DicDynamicProperties[outputOne].Value = null;
    333323    }
    334324
     
    347337    public void Dispose()
    348338    {
    349       foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    350       {
    351         cryptoolStream.Close();
    352       }
    353       listCryptoolStreamsOut.Clear();
    354       // This values have to be set to null here because it might be CryptoolStreams.
    355       // The files will be deleted before each run. So the quickWatch calls on PreExec
    356       // will produce an exception, because MethodGetValue tries to access the old files if not
    357       // set to null here.
    358       DicDynamicProperties[inputOne].Value = null;
    359       DicDynamicProperties[inputTwo].Value = null;
    360       DicDynamicProperties[outputOne].Value = null;
    361     }
     339      }
    362340
    363341    #endregion
  • trunk/CrypPlugins/Converter/Converter.cs

    r2334 r2529  
    4242        #endregion
    4343
    44         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    45 
    4644        #region public interfaces
    4745
     
    111109                    if (streamData != null)
    112110                    {
    113                         CryptoolStream stream = new CryptoolStream();
    114                         listCryptoolStreamsOut.Add(stream);
    115                         stream.OpenRead(streamData);
    116                         return stream;
     111                        ICryptoolStream cStream = new CStreamWriter(streamData);
     112                        return cStream;
    117113                    }
    118114                    else
     
    142138        public void Dispose()
    143139        {
    144             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    145                 stream.Close();
    146140        }
    147141
     
    151145                GuiLogMessage("Laufe! " + InputOne.ToString(), NotificationLevel.Debug);
    152146
    153             if (!(InputOne is int[] || InputOne is CryptoolStream))
     147            if (!(InputOne is int[] || InputOne is ICryptoolStream))
    154148            {
    155149                if (inputOne is bool)
  • trunk/CrypPlugins/CubeAttack/CubeAttack.cs

    r2334 r2529  
    3232        private string outputKeyBits;
    3333        private enum CubeAttackMode { preprocessing, online, setPublicBits };
    34         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    3534        private bool stop = false;
    3635       
     
    6463            QuickWatchFormat.Text,
    6564            null)]
    66         public CryptoolStream OutputSuperpoly
     65        public ICryptoolStream OutputSuperpoly
    6766        {
    6867            get
     
    7069                if (outputSuperpoly != null)
    7170                {
    72                     CryptoolStream cs = new CryptoolStream();
    73                     listCryptoolStreamsOut.Add(cs);
    74                     cs.OpenRead(Encoding.Default.GetBytes(outputSuperpoly.ToCharArray()));
    75                     return cs;
     71                    return new CStreamWriter(Encoding.Default.GetBytes(outputSuperpoly));
    7672                }
    7773                else
     
    9288            QuickWatchFormat.Text,
    9389            null)]
    94         public CryptoolStream OutputKeyBits
     90        public ICryptoolStream OutputKeyBits
    9591        {
    9692            get
     
    9894                if (outputKeyBits != null)
    9995                {
    100                     CryptoolStream cs = new CryptoolStream();
    101                     listCryptoolStreamsOut.Add(cs);
    102                     cs.OpenRead(Encoding.Default.GetBytes(outputKeyBits.ToCharArray()));
    103                     return cs;
     96                    return new CStreamWriter(Encoding.Default.GetBytes(outputKeyBits));
    10497                }
    10598                else
     
    161154        {
    162155            stop = false;
    163             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    164             {
    165                 stream.Close();
    166             }
    167             listCryptoolStreamsOut.Clear();
    168         }
     156            }
    169157
    170158        public bool HasChanges
  • trunk/CrypPlugins/DES/DES.cs

    r2334 r2529  
    2525        #region Private variables
    2626        private DESSettings settings;
    27         private CryptoolStream inputStream;
    28         private CryptoolStream outputStream;
    29         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    3027        private byte[] inputKey;
    3128        private byte[] inputIV;
     29        private CStreamWriter writer;
    3230        private CryptoStream p_crypto_stream;
    3331        private bool stop = false;
     
    7573
    7674        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", null, true, false, QuickWatchFormat.Hex, null)]
    77         public CryptoolStream InputStream
    78         {
    79             get
    80             {
    81                 if (inputStream != null)
    82                 {
    83                     CryptoolStream cs = new CryptoolStream();
    84                     cs.OpenRead(inputStream.FileName);
    85                     listCryptoolStreamsOut.Add(cs);
    86                     return cs;
    87                 }
    88                 else return null;
    89             }
    90             set
    91             {
    92               this.inputStream = value;
    93               if (value != null) listCryptoolStreamsOut.Add(value);
    94               OnPropertyChanged("InputStream");
    95             }
    96         }
     75        public ICryptoolStream InputStream
     76        {
     77            get;
     78            set;
     79                }
    9780
    9881        [PropertyInfo(Direction.InputData, "Key", "The key for encryption7decryption. It must be exactly 8 bytes (64 Bits).", null, true, false, QuickWatchFormat.Hex, null)]
     
    119102       
    120103        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", null, true, false, QuickWatchFormat.Hex, null)]
    121         public CryptoolStream OutputStream
     104        public ICryptoolStream OutputStream
    122105        {
    123106            get
    124107            {
    125                 if (this.outputStream != null)
    126                 {
    127                     CryptoolStream cs = new CryptoolStream();
    128                     listCryptoolStreamsOut.Add(cs);
    129                     cs.OpenRead(this.outputStream.FileName);
    130                     return cs;
    131                 }
    132                 return null;
    133             }
    134             set
    135             {
    136                 outputStream = value;
    137                 if (value != null) listCryptoolStreamsOut.Add(value);
    138                 OnPropertyChanged("OutputStream");
    139             }
    140         }
     108                return writer;
     109                }
     110            }
    141111
    142112        #endregion       
     
    194164                inputIV = null;
    195165
    196                 inputStream = null;
    197                 outputStream = null;
    198 
    199                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    200                 {
    201                     stream.Close();
    202                 }
    203                 listCryptoolStreamsOut.Clear();
     166                if (writer != null)
     167                {
     168                    writer.Dispose();
     169                    writer = null;
     170                }
    204171
    205172                if (p_crypto_stream != null)
     
    299266        private void checkForInputStream()
    300267        {
    301             if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
     268            if (settings.Action == 0 && (InputStream == null || InputStream.Length == 0))
    302269            {
    303270                //create some input
    304271                String dummystring = "Dummy string - no input provided - \"Hello DES World\" - dummy string - no input provided!";
    305                 this.inputStream = new CryptoolStream();
    306                 this.inputStream.OpenRead(Encoding.Default.GetBytes(dummystring.ToCharArray()));
     272                InputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring.ToCharArray()));
    307273                // write a warning to the ouside word
    308274                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     
    316282            {
    317283                checkForInputStream();
    318                 if (inputStream == null || (inputStream != null && inputStream.Length == 0))
     284                if (InputStream == null || InputStream.Length == 0)
    319285                {
    320286                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    322288                }
    323289
    324                 if (this.inputStream.CanSeek) this.inputStream.Position = 0;
    325290                SymmetricAlgorithm p_alg = new DESCryptoServiceProvider();
    326291
     
    338303                }
    339304
    340                 outputStream = new CryptoolStream();
    341                 listCryptoolStreamsOut.Add(outputStream);
    342                 outputStream.OpenWrite();
    343                 p_crypto_stream = new CryptoStream((Stream)inputStream, p_encryptor, CryptoStreamMode.Read);
     305                writer = new CStreamWriter();
     306                using (CStreamReader reader = InputStream.CreateReader())
     307                {
     308                    p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read);
    344309                byte[] buffer = new byte[p_alg.BlockSize / 8];
    345310                int bytesRead;
     
    349314                while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
    350315                {
    351                     outputStream.Write(buffer, 0, bytesRead);
    352 
    353                     if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     316                        writer.Write(buffer, 0, bytesRead);
     317
     318                        if ((int)(reader.Position * 100 / reader.Length) > position)
    354319                    {
    355                         position = (int)(inputStream.Position * 100 / inputStream.Length);
    356                         ProgressChanged(inputStream.Position, inputStream.Length);
     320                            position = (int)(reader.Position * 100 / reader.Length);
     321                            ProgressChanged(reader.Position, reader.Length);
    357322                    }
    358323                }
     
    363328                if (!stop)
    364329                {
    365                     GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
    366                     GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
     330                        GuiLogMessage("Encryption complete! (in: " + reader.Length.ToString() + " bytes, out: " + writer.Length.ToString() + " bytes)", NotificationLevel.Info);
    367331                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    368                     outputStream.Close();
     332                        writer.Close();
    369333                    OnPropertyChanged("OutputStream");
    370334                }
    371335                if (stop)
    372336                {
    373                     outputStream.Close();
     337                        writer.Close();
    374338                    GuiLogMessage("Aborted!", NotificationLevel.Info);
     339                }
    375340                }
    376341                ProgressChanged(1, 1);
  • trunk/CrypPlugins/FileInput/FileInput.cs

    r2334 r2529  
    3838        private FileInputPresentation fileInputPresentation;
    3939        private FileInputSettings settings;
    40         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     40        private CStreamWriter cstreamWriter;
    4141        #endregion
    4242
     
    8383
    8484        [PropertyInfo(Direction.OutputData, "Stream Output", "Selected file as stream.", "", true, false, QuickWatchFormat.Hex, null)]
    85         public CryptoolStream StreamOutput
     85        public ICryptoolStream StreamOutput
    8686        {
    8787            get
    8888            {
    89                 try
    90                 {
    91                     Progress(0.5, 1.0);
    92                     if (File.Exists(settings.OpenFilename))
    93                     {
    94                         CryptoolStream cryptoolStream = new CryptoolStream();
    95                         cryptoolStream.OpenRead(settings.OpenFilename);
    96                         listCryptoolStreamsOut.Add(cryptoolStream);
    97 
    98                         Progress(1.0, 1.0);
    99                         return cryptoolStream;
     89                return cstreamWriter;
    10090                    }
    101                     return null;
    102                 }
    103                 catch (Exception exception)
    104                 {
    105                     GuiLogMessage(exception.Message, NotificationLevel.Error);
    106                     return null;
    107                 }
    108             }
    10991            set { } // readonly
    11092        }
     
    152134        public void Dispose()
    153135        {
    154             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    155                 stream.Close();
    156 
    157             listCryptoolStreamsOut.Clear();
     136            if (cstreamWriter != null)
     137            {
     138                cstreamWriter.Dispose();
     139                cstreamWriter = null;
     140            }
     141
    158142            fileInputPresentation.CloseFileToGetFileStreamForExecution();
    159143        }
     
    168152            DispatcherHelper.ExecuteMethod(fileInputPresentation.Dispatcher,
    169153              fileInputPresentation, "CloseFileToGetFileStreamForExecution", null);
    170             Dispose();
    171154        }
    172155
    173156        public void PostExecution()
    174157        {
    175             Dispose();
    176158            DispatcherHelper.ExecuteMethod(fileInputPresentation.Dispatcher,
    177159              fileInputPresentation, "ReopenClosedFile", null);
     
    214196        public void Execute()
    215197        {
     198            cstreamWriter = new CStreamWriter(settings.OpenFilename);
    216199            NotifyPropertyChange();
    217200        }
  • trunk/CrypPlugins/FileOutput/FileOutput.cs

    r2334 r2529  
    3737    #region Private variables   
    3838    public FileOutputSettings settings = null;
    39     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4039    #endregion Private variables
    4140
     
    7372
    7473    # region Properties
    75     private CryptoolStream streamInput;
    7674
    7775    [PropertyInfo(Direction.InputData, "Stream Input", "Display the input file in HexEditor.", "", true, false, QuickWatchFormat.Hex, null)]
    78     public CryptoolStream StreamInput
    79     {
    80       get
    81       {
    82         if (File.Exists(InputFile))
    83         {
    84           CryptoolStream cs = new CryptoolStream();
    85           cs.OpenRead(InputFile);
    86           listCryptoolStreamsOut.Add(cs);
    87           return cs;
     76        public ICryptoolStream StreamInput
     77    {
     78            get;
     79            set;
    8880        }
    89         return null;
    90       }
    91       set
    92       {
    93         Progress(0.5, 1.0);
    94         if (value != null)
    95         {         
    96           listCryptoolStreamsOut.Add(value);
    97           GuiLogMessage("Received ICryptoolStream: " + value.FileName, NotificationLevel.Debug);
    98           streamInput = value;
    99           InputFile = value.FileName;
    100           OnPropertyChanged("StreamInput");
    101 
    102           // If target file was selected we have to copy the input to target.
    103           # region copyToTarget
    104           if (settings.TargetFilename != null)
    105           {
    106             listCryptoolStreamsOut.Add(value);
    107             InputFile = settings.TargetFilename;
    108             try
    109             {
    110               fileOutputPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    111               {
    112                 fileOutputPresentation.ClosePresentationFile();
    113               }, null);
    114 
    115               value.Seek(0, SeekOrigin.Begin);
    116               FileStream fs = FileHelper.GetFileStream(settings.TargetFilename, FileMode.Create);
    117               byte[] byteValues = new byte[1024];
    118               int byteRead;
    119 
    120               int position = 0;
    121               GuiLogMessage("Start writing to target file now: " + settings.TargetFilename, NotificationLevel.Debug);
    122               while ((byteRead = value.Read(byteValues, 0, byteValues.Length)) != 0)
    123               {
    124                 fs.Write(byteValues, 0, byteRead);
    125                 if (OnPluginProgressChanged != null && value.Length > 0 &&
    126                     (int)(value.Position * 100 / value.Length) > position)
    127                 {
    128                   position = (int)(value.Position * 100 / value.Length);
    129                   Progress(value.Position, value.Length);
    130                 }
    131               }
    132               fs.Flush();
    133               fs.Close();
    134 
    135               GuiLogMessage("Finished writing: " + settings.TargetFilename, NotificationLevel.Debug);
    136             }
    137             catch (Exception ex)
    138             {
    139               GuiLogMessage(ex.Message, NotificationLevel.Error);
    140               settings.TargetFilename = null;
    141             }
    142           }
    143           # endregion copyToTarget
    144           value.Close();
    145 
    146           fileOutputPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    147           {
    148             fileOutputPresentation.OpenPresentationFile();
    149           }, null);
    150           Progress(1.0, 1.0);
    151         }
    152         else
    153         {
    154           GuiLogMessage("Received null value for ICryptoolStream.", NotificationLevel.Warning);
    155         }       
    156       }
    157     }
    15881    #endregion
    15982
     
    185108    public void Dispose()
    186109    {
    187       foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    188       {
    189         cryptoolStream.Close();
    190       }
    191       listCryptoolStreamsOut.Clear();
    192 
    193110      DispatcherHelper.ExecuteMethod(fileOutputPresentation.Dispatcher,
    194111        fileOutputPresentation, "OpenPresentationFile", null);
     
    205122      DispatcherHelper.ExecuteMethod(fileOutputPresentation.Dispatcher,
    206123        fileOutputPresentation, "ClosePresentationFile", null);
    207       if (settings.TargetFilename == null || settings.TargetFilename == string.Empty)
     124            if (string.IsNullOrEmpty(settings.TargetFilename))
    208125      {
    209126        GuiLogMessage("You have to select a target filename before using this plugin as output.", NotificationLevel.Error);
     
    213130    public void PostExecution()
    214131    {
    215       Dispose();
    216132    }
    217133
     
    246162    public void Execute()
    247163    {
     164            Progress(0.5, 1.0);
     165            if (StreamInput == null)
     166            {
     167                GuiLogMessage("Received null value for ICryptoolStream.", NotificationLevel.Warning);
     168                return;
     169            }
    248170     
    249     }
     171            using (CStreamReader reader = StreamInput.CreateReader())
     172            {
     173                // If target file was selected we have to copy the input to target.
     174                # region copyToTarget
     175                if (settings.TargetFilename != null)
     176                {
     177                    InputFile = settings.TargetFilename;
     178                    try
     179                    {
     180                        fileOutputPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     181                        {
     182                            fileOutputPresentation.ClosePresentationFile();
     183                        }, null);
     184
     185                        FileStream fs = FileHelper.GetFileStream(settings.TargetFilename, FileMode.Create);
     186                        byte[] byteValues = new byte[1024];
     187                        int byteRead;
     188
     189                        int position = 0;
     190                        GuiLogMessage("Start writing to target file now: " + settings.TargetFilename, NotificationLevel.Debug);
     191                        while ((byteRead = reader.Read(byteValues, 0, byteValues.Length)) != 0)
     192                        {
     193                            fs.Write(byteValues, 0, byteRead);
     194                            if (OnPluginProgressChanged != null && reader.Length > 0 &&
     195                                (int)(reader.Position * 100 / reader.Length) > position)
     196                            {
     197                                position = (int)(reader.Position * 100 / reader.Length);
     198                                Progress(reader.Position, reader.Length);
     199    }
     200                        }
     201                        fs.Flush();
     202                        fs.Close();
     203
     204                        GuiLogMessage("Finished writing: " + settings.TargetFilename, NotificationLevel.Debug);
     205                    }
     206                    catch (Exception ex)
     207                    {
     208                        GuiLogMessage(ex.Message, NotificationLevel.Error);
     209                        settings.TargetFilename = null;
     210                    }
     211                }
     212                # endregion copyToTarget
     213
     214                fileOutputPresentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     215                {
     216                    fileOutputPresentation.OpenPresentationFile();
     217                }, null);
     218                Progress(1.0, 1.0);
     219            }
     220        }
    250221
    251222    public void Pause()
  • trunk/CrypPlugins/HIGHT/HIGHT.cs

    r2334 r2529  
    3939
    4040        private HIGHTSettings settings;
    41         private CryptoolStream inputStream;
    42         private CryptoolStream outputStream;
     41        private ICryptoolStream inputStream;
     42        private CStreamWriter outputStreamWriter;
    4343        private byte[] inputKey;
    4444        private bool stop = false;
    45         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4645
    4746        #endregion
     
    6059
    6160        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted.", "", true, false, QuickWatchFormat.Hex, null)]
    62         public CryptoolStream InputStream
     61        public ICryptoolStream InputStream
    6362        {
    6463            get
    6564            {
    66               if (inputStream != null)
    67               {
    68                 CryptoolStream cs = new CryptoolStream();
    69                 cs.OpenRead(inputStream.FileName);
    70                 listCryptoolStreamsOut.Add(cs);
    71                 return cs;
     65                return inputStream;
    7266              }
    73               else return null;
    74             }
    7567            set
    7668            {
    7769              this.inputStream = value;
    78               if (value != null) listCryptoolStreamsOut.Add(value);
    79               OnPropertyChanged("InputStream");
     70             
     71              // wander 20100208: unnecessary event, should be propagated by editor
     72              //OnPropertyChanged("InputStream");
    8073            }
    8174        }
     
    9386
    9487        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", "", true, false, QuickWatchFormat.Hex, null)]
    95         public CryptoolStream OutputStream
     88        public ICryptoolStream OutputStream
    9689        {
    9790            get
    9891            {
    99                 if (this.outputStream != null)
    100                 {
    101                     CryptoolStream cs = new CryptoolStream();
    102                     listCryptoolStreamsOut.Add(cs);
    103                     cs.OpenRead(this.outputStream.FileName);
    104                     return cs;
    105                 }
    106                 return null;
    107             }
     92                return outputStreamWriter;
     93                }
    10894            set
    10995            {
    110                 outputStream = value;
    111                 if (value != null) listCryptoolStreamsOut.Add(value);
    112                 OnPropertyChanged("OutputStream");
    11396            }
    11497        }
     
    11699        public void Dispose()
    117100        {
    118             try
    119             {
    120101                stop = false;
    121102                inputKey = null;
    122                 outputStream = null;
     103            outputStreamWriter = null;
    123104                inputStream = null;
    124 
    125                 if (inputStream != null)
    126                 {
    127                     inputStream.Flush();
    128                     inputStream.Close();
    129                     inputStream = null;
    130                 }
    131                 if (outputStream != null)
    132                 {
    133                     outputStream.Flush();
    134                     outputStream.Close();
    135                     outputStream = null;
    136                 }
    137                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    138                 {
    139                     stream.Close();
    140                 }
    141                 listCryptoolStreamsOut.Clear();
    142             }
    143             catch (Exception ex)
    144             {
    145                 GuiLogMessage(ex.Message, NotificationLevel.Error);
    146             }
    147             this.stop = false;
    148         }
     105                }
    149106
    150107        private void checkForInputStream()
    151108        {
    152             if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
     109            if (settings.Action == 0 && (inputStream == null || inputStream.Length == 0))
    153110            {
    154111                //create some input
    155112                String dummystring = "12345678";
    156                 this.inputStream = new CryptoolStream();
    157                 this.inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
     113                this.inputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring));
    158114                // write a warning to the outside world
    159115                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     
    173129                checkForInputStream();
    174130
    175                 if (inputStream == null || (inputStream != null && inputStream.Length == 0))
     131                if (inputStream == null || inputStream.Length == 0)
    176132                {
    177133                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    179135                }
    180136
    181                 if (this.inputStream.CanSeek) this.inputStream.Position = 0;
    182 
    183                 outputStream = new CryptoolStream();
    184                 listCryptoolStreamsOut.Add(outputStream);
    185                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     137                outputStreamWriter = new CStreamWriter();
    186138
    187139                long inputbytes = inputStream.Length;
     
    207159                GuiLogMessage("# of blocks: " + blocks.ToString(), NotificationLevel.Debug);
    208160
     161                using (CStreamReader reader = inputStream.CreateReader())
     162                {
     163
    209164                //read input
    210165                //GuiLogMessage("Current position: " + inputStream.Position.ToString(), NotificationLevel.Debug);
     
    216171                        if (position < inputbytes)
    217172                        {
    218                             inputbuffer[position] = (byte)inputStream.ReadByte();
     173                                inputbuffer[position] = (byte)reader.ReadByte();
    219174                        }
    220175                        else // padding to do!
     
    234189                            {
    235190                                // no padding
    236                                 inputbuffer[position] = (byte)inputStream.ReadByte();
     191                                    inputbuffer[position] = (byte)reader.ReadByte();
    237192                                GuiLogMessage("Byte is: " + inputbuffer[position].ToString(), NotificationLevel.Info);
    238193                            }
     
    286241                        //write buffer to output stream
    287242                        outputbuffer = BitConverter.GetBytes(vector[0]);
    288                         outputStream.Write(outputbuffer, 0, 4);
     243                            outputStreamWriter.Write(outputbuffer, 0, 4);
    289244                        outputbuffer = BitConverter.GetBytes(vector[1]);
    290                         outputStream.Write(outputbuffer, 0, 4);
     245                            outputStreamWriter.Write(outputbuffer, 0, 4);
    291246                    }
    292                 } else if (action == 1) {
     247                    }
     248                    else if (action == 1)
     249                    {
    293250                    StatusChanged((int)HIGHTImage.Decode);
    294251                    GuiLogMessage("Starting decryption [Keysize=128 Bits, Blocksize=64 Bits]", NotificationLevel.Info);
     
    302259                        //write buffer to output stream
    303260                        outputbuffer = BitConverter.GetBytes(vector[0]);
    304                         outputStream.Write(outputbuffer, 0, 4);
     261                            outputStreamWriter.Write(outputbuffer, 0, 4);
    305262                        outputbuffer = BitConverter.GetBytes(vector[1]);
    306                         outputStream.Write(outputbuffer, 0, 4);
     263                            outputStreamWriter.Write(outputbuffer, 0, 4);
    307264                    }
    308265                }
     
    318275                }*/
    319276
    320                 long outbytes = outputStream.Length;
     277                    long outbytes = outputStreamWriter.Length;
    321278                DateTime stopTime = DateTime.Now;
    322279                TimeSpan duration = stopTime - startTime;
     
    333290                        GuiLogMessage("Decryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    334291                    }
    335                     GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Debug);
    336292                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    337                     outputStream.Close();
     293                        outputStreamWriter.Close();
    338294                    OnPropertyChanged("OutputStream");
    339295                }
     
    341297                if (stop)
    342298                {
    343                     outputStream.Close();
     299                        outputStreamWriter.Close();
    344300                    GuiLogMessage("Aborted!", NotificationLevel.Info);
    345301                }
     302            }
    346303            }
    347304            /*catch (CryptographicException cryptographicException)
  • trunk/CrypPlugins/HMAC/HMAC.cs

    r2334 r2529  
    3939
    4040        private HMACSettings settings;
    41         private CryptoolStream inputData;
     41        private ICryptoolStream inputData;
    4242        private byte[] key;
    4343        private byte[] outputData;
    44         private List<CryptoolStream> streamList = new List<CryptoolStream>();
    4544
    4645        #endregion
     
    6160
    6261        [PropertyInfo(Direction.InputData, "Input stream", "Input data to be processed", "", true, false, QuickWatchFormat.Hex, null)]
    63         public CryptoolStream InputData
    64         {
    65 
    66             get
    67             {
    68                 if (inputData != null)
    69                 {
    70                     CryptoolStream cs = new CryptoolStream();
    71                     cs.OpenRead(inputData.FileName);
    72                     streamList.Add(cs);
    73                     return cs;
    74                 }
    75                 return null;
    76             }
     62        public ICryptoolStream InputData
     63        {
     64
     65            get
     66            {
     67                return inputData;
     68                }
    7769
    7870            set
     
    9991
    10092        [PropertyInfo(Direction.OutputData, "Digested value", "Digested value as stream", "", false, false, QuickWatchFormat.Hex, null)]
    101         public CryptoolStream OutputDataStream
     93        public ICryptoolStream OutputDataStream
    10294        {
    10395            get
     
    10597                if (outputData != null)
    10698                {
    107                     CryptoolStream stream = new CryptoolStream();
    108                     streamList.Add(stream);
    109                     stream.OpenRead(outputData);
    110                     GuiLogMessage("Got request for hash (Stream)...", NotificationLevel.Debug);
    111                     return stream;
     99                    return new CStreamWriter(outputData);
    112100                }
    113101                else
     
    170158
    171159                hmacAlgorithm.Key = key;
    172                 OutputData = hmacAlgorithm.ComputeHash(inputData);
     160                using (CStreamReader reader = inputData.CreateReader())
     161                {
     162                    OutputData = hmacAlgorithm.ComputeHash(reader);
     163                }
    173164
    174165                GuiLogMessage(String.Format("HMAC computed. (using hash algorithm {0}: {1})", settings.SelectedHashFunction, hmacAlgorithm.GetType().Name), NotificationLevel.Info);
     
    190181        public void Dispose()
    191182        {
    192             if (inputData != null)
    193             {
    194                 inputData.Close();
    195183                inputData = null;
    196184            }
    197             foreach (CryptoolStream stream in streamList)
    198             {
    199                 stream.Close();
    200             }
    201         }
    202185        #endregion
    203186
  • trunk/CrypPlugins/Internet_frame_generator/Internet_frame_generator/Internet_frame_generator.cs

    r582 r2529  
    3535        private Internet_frame_generatorSettings settings;
    3636        private int inputInt;
    37         private CryptoolStream outputStream;
    38         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     37        private CStreamWriter outputStream;
    3938        private bool stop = false;
    4039        private Internet_frame_generator_Presentation presentation;
     
    7473            QuickWatchFormat.Hex,
    7574            null)]
    76         public CryptoolStream OutputStream
     75        public ICryptoolStream OutputStream
    7776        {
    7877            get
    7978            {
    80                 if (this.outputStream != null)
    81                 {
    82                     CryptoolStream cs = new CryptoolStream();
    83                     listCryptoolStreamsOut.Add(cs);
    84                     cs.OpenRead(this.outputStream.FileName);
    85                     return cs;
     79                return outputStream;
    8680                }
    87                 return null;
    88             }
    8981            set
    9082            {
    91                 outputStream = value;
    92                 if (value != null) listCryptoolStreamsOut.Add(value);
    93                 OnPropertyChanged("OutputStream");
    9483            }
    9584        }
     
    544533                stop = false;
    545534                outputStream = null;
    546                 foreach (CryptoolStream cs in listCryptoolStreamsOut)
    547                 {
    548                     cs.Close();
    549                 }
    550                 listCryptoolStreamsOut.Clear();
    551535                rnd = null;
    552536            }
     
    570554                string successMessage = string.Empty;
    571555                packetCounter = 0;
    572                 outputStream = new CryptoolStream();
    573                 listCryptoolStreamsOut.Add(outputStream);
    574                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     556                outputStream = new CStreamWriter();
    575557                outputStream.Write(header, 0, header.Length);
    576558                // IPv4 packets are requested
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r2527 r2529  
    143143
    144144        /* BEGIN: following lines are from Arnie - 2010.01.12 */
    145         CryptoolStream csEncryptedData;
     145        ICryptoolStream csEncryptedData;
    146146        [PropertyInfo(Direction.InputData, "CS_Encrypted_Data", "csEncryptedDataDesc", "", false, false, QuickWatchFormat.Hex, "")]
    147         public virtual CryptoolStream CSEncryptedData
     147        public virtual ICryptoolStream CSEncryptedData
    148148        {
    149149            get { return this.csEncryptedData; }
     
    177177        /// When the Input-Slot changed, set this variable to true, so the new Stream will be transformed to byte[]
    178178        /// </summary>
    179         private byte[] GetByteFromCryptoolStream(CryptoolStream cryptoolStream)
     179        private byte[] GetByteFromCryptoolStream(ICryptoolStream cryptoolStream)
    180180        {
    181181            byte[] encryptedByteData = null;
     
    183183            if (cryptoolStream != null)
    184184            {
    185                 CryptoolStream cs = new CryptoolStream();
    186                 cs.OpenRead(cryptoolStream.FileName);
    187                 encryptedByteData = new byte[cs.Length];
    188                 if(cs.Length > Int32.MaxValue)
     185                using (CStreamReader reader = cryptoolStream.CreateReader())
     186                {
     187                    if (reader.Length > Int32.MaxValue)
    189188                    throw(new Exception("CryptoolStream length is longer than the Int32.MaxValue"));
    190                 cs.Read(encryptedByteData, 0, (int)cs.Length);
     189
     190                    encryptedByteData = reader.ReadFully();
     191            }
    191192            }
    192193            return encryptedByteData;
  • trunk/CrypPlugins/LFSR/LFSR.cs

    r2334 r2529  
    5959       
    6060        private LFSRPresentation lFSRPresentation;
    61         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    6261
    6362        #endregion
  • trunk/CrypPlugins/MD5/MD5.cs

    r2334 r2529  
    4646
    4747        private MD5Settings settings;
    48         private CryptoolStream inputData;
     48        private ICryptoolStream inputData;
    4949        private byte[] outputData;
    50         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    5150        private PresentableMD5 md5;
    5251        private PresentationContainer presentationContainer;
     
    7776
    7877        [PropertyInfo(Direction.InputData, "Input stream", "Input data to be hashed", "", true, false, QuickWatchFormat.Hex, null)]
    79         public CryptoolStream InputData
    80         {
    81          
     78        public ICryptoolStream InputData
     79        {
    8280            get
    8381            {
    84               if (inputData != null)
    85               {
    86                 CryptoolStream cs = new CryptoolStream();
    87                 cs.OpenRead(inputData.FileName);
    88                 listCryptoolStreamsOut.Add(cs);
    89                 return cs;
     82                return inputData;
    9083              }
    91               return null;   
    92             }
    9384         
    9485            set
     
    10091
    10192        [PropertyInfo(Direction.OutputData, "Hashed value", "Output data of the hashed value as Stream", "", false, false, QuickWatchFormat.Hex, null)]
    102         public CryptoolStream OutputDataStream
     93        public ICryptoolStream OutputDataStream
    10394        {
    10495          get
     
    10697            if (outputData != null)
    10798            {
    108               CryptoolStream stream = new CryptoolStream();             
    109               listCryptoolStreamsOut.Add(stream);
    110               stream.OpenRead(outputData);
    11199              GuiLogMessage("Got request for hash (Stream)...", NotificationLevel.Debug);
    112               return stream;
     100                return new CStreamWriter(outputData);
    113101            }
    114102            return null; ;
     
    148136          if (inputData != null)
    149137          {
     138              using (CStreamReader reader = inputData.CreateReader())
     139              {
    150140              if (Presentation.IsVisible)
    151141              {
    152                   md5.Initialize(inputData);
     142                      md5.Initialize(reader);
    153143              }
    154144              else
    155145              {
    156146                  HashAlgorithm builtinMd5 = System.Security.Cryptography.MD5.Create();
    157                   OutputData = builtinMd5.ComputeHash(inputData);
     147
     148                      OutputData = builtinMd5.ComputeHash(reader);
     149
    158150                  ProgressChanged(1.0, 1.0);
    159151              }
     152          }
    160153          }
    161154          else
     
    172165        public void Dispose()
    173166        {
    174           if (inputData != null)
    175           {
    176             inputData.Close();
    177167            inputData = null;
    178168          }
    179           foreach (CryptoolStream stream in listCryptoolStreamsOut)
    180           {
    181             stream.Close();
    182           }
    183         }
    184169        #endregion
    185170
  • trunk/CrypPlugins/MD5Collider/MD5Collider.cs

    r2334 r2529  
    1919    {
    2020        private MD5ColliderSettings settings = new MD5ColliderSettings();
    21         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    2221        private QuickWatchPresentationContainer quickWatchPresentation = new QuickWatchPresentationContainer();
    2322
     
    6463
    6564        [PropertyInfo(Direction.OutputData, "First colliding data block", "First colliding data block as Stream", "", false, false, QuickWatchFormat.Hex, null)]
    66         public CryptoolStream OutputDataStream1
     65        public ICryptoolStream OutputDataStream1
    6766        {
    6867            get
     
    7069                if (outputData1 != null)
    7170                {
    72                     CryptoolStream stream = new CryptoolStream();
    73                     listCryptoolStreamsOut.Add(stream);
    74                     stream.OpenRead(outputData1);
    75                     return stream;
     71                    return new CStreamWriter(outputData1);
    7672                }
    7773                else
    78                     return null; ;
     74                {
     75                    return null;
    7976            }
     77        }
    8078        }
    8179
     
    9492
    9593        [PropertyInfo(Direction.OutputData, "Second colliding data block", "Second colliding data block as Stream", "", false, false, QuickWatchFormat.Hex, null)]
    96         public CryptoolStream OutputDataStream2
     94        public ICryptoolStream OutputDataStream2
    9795        {
    9896            get
     
    10098                if (outputData2 != null)
    10199                {
    102                     CryptoolStream stream = new CryptoolStream();
    103                     listCryptoolStreamsOut.Add(stream);
    104                     stream.OpenRead(outputData2);
    105                     return stream;
     100                    return new CStreamWriter(outputData2);
    106101                }
    107102                else
    108                     return null; ;
     103                {
     104                    return null;
    109105            }
     106        }
    110107        }
    111108
     
    163160        public void Dispose()
    164161        {
    165             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    166                 stream.Close();
    167             listCryptoolStreamsOut.Clear();
    168162        }
    169163
  • trunk/CrypPlugins/Multiplexer/Mux.cs

    r2334 r2529  
    3434  {
    3535    #region Private variables
    36     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    37 
    3836    private readonly string inputOne = "InputOne";
    3937    private readonly string inputTwo = "InputTwo";
     
    107105      switch (settings.CurrentDataType)
    108106      {
    109         case MuxSettings.DataTypes.CryptoolStream:
    110           return typeof(CryptoolStream);         
     107        case MuxSettings.DataTypes.ICryptoolStream:
     108          return typeof(ICryptoolStream);
    111109        case MuxSettings.DataTypes.String:
    112110          return typeof(string);
     
    125123    {
    126124      Type type = getCurrentType();
    127       if (type == typeof(CryptoolStream))
     125      if (type == typeof(ICryptoolStream))
    128126        return QuickWatchFormat.Hex;
    129127      else if (type == typeof(string))
     
    143141      if (DicDynamicProperties.ContainsKey(name))
    144142      {
    145         switch (settings.CurrentDataType)
    146         {
    147           case MuxSettings.DataTypes.CryptoolStream:
    148             CryptoolStream cryptoolStream = new CryptoolStream();
    149             listCryptoolStreamsOut.Add(cryptoolStream);
    150             cryptoolStream.OpenRead(((CryptoolStream)DicDynamicProperties[name].Value).FileName);
    151             return cryptoolStream;
    152           case MuxSettings.DataTypes.String:
    153143            return DicDynamicProperties[name].Value;
    154           case MuxSettings.DataTypes.ByteArray:
    155             return DicDynamicProperties[name].Value;
    156           case MuxSettings.DataTypes.Boolean:
    157             return DicDynamicProperties[name].Value;
    158           case MuxSettings.DataTypes.Integer:
    159             return DicDynamicProperties[name].Value;
    160           default:
    161             return null;
    162144        }
    163       }
    164145      return null;
    165146    }
     
    188169    public void methodSetValue(string propertyKey, object value)
    189170    {
    190       if (DicDynamicProperties.ContainsKey(propertyKey)) DicDynamicProperties[propertyKey].Value = value;
    191       if (value is CryptoolStream) listCryptoolStreamsOut.Add((CryptoolStream)value);
     171      if (DicDynamicProperties.ContainsKey(propertyKey))
     172          DicDynamicProperties[propertyKey].Value = value;
    192173      OnPropertyChanged(propertyKey);
    193174      dicInputBuffer[propertyKey]++;
     
    329310    public void Dispose()
    330311    {
    331       foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    332       {
    333         cryptoolStream.Close();
    334       }
    335       listCryptoolStreamsOut.Clear();
    336312      foreach (DynamicProperty item in DicDynamicProperties.Values)
    337313      {
     
    352328
    353329    #endregion
    354 
    355     private CryptoolStream getNewCryptoolStream(string Filename)
    356     {
    357       CryptoolStream cryptoolStream = new CryptoolStream();
    358       cryptoolStream.OpenRead(Filename);
    359       listCryptoolStreamsOut.Add(cryptoolStream);
    360       return cryptoolStream;
    361330    }
    362331  }
    363 }
  • trunk/CrypPlugins/Multiplexer/MuxSettings.cs

    r2334 r2529  
    1 /*
     1/*
    22   Copyright 2008 Thomas Schmid, University of Siegen
    33
     
    3131    public enum DataTypes
    3232    {
    33       CryptoolStream, String, ByteArray, Boolean, Integer
     33      ICryptoolStream, String, ByteArray, Boolean, Integer
    3434    }
    3535
     
    9797    }
    9898   
    99     [TaskPane("Type", "Select DataType of plugin.", "", 2, false, ControlType.ComboBox, new string[] { "CryptoolStream", "string", "byte[]", "boolean", "int" } )]
     99    [TaskPane("Type", "Select DataType of plugin.", "", 2, false, ControlType.ComboBox, new string[] { "ICryptoolStream", "string", "byte[]", "boolean", "int" } )]
    100100    public int DataType
    101101    {
  • trunk/CrypPlugins/PKCS1

  • trunk/CrypPlugins/PKCS5/PKCS5.cs

    r2334 r2529  
    197197          //case argType.Stream:
    198198            {
    199               CryptoolStream keyDataStream = new CryptoolStream();
    200               keyDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, key);
    201               return keyDataStream;
     199                return new CStreamWriter(key);
    202200            }
    203201
     
    214212          return;
    215213
    216         if (Object.ReferenceEquals(value.GetType(), typeof(CryptoolStream)))
     214        if (value is ICryptoolStream)
    217215        {
    218216          keyType = argType.Stream;
    219217
    220           CryptoolStream cst = (CryptoolStream)value;
     218          using (CStreamReader cst = ((ICryptoolStream)value).CreateReader())
     219          {
     220              /// FIXME: potentially broken. Shall not rely on Length property to return
     221              /// final value.
    221222          long len = cst.Length;
    222223          key = new byte[len];
     
    224225          for (long i = 0; i < len; i++)
    225226            key[i] = (byte)cst.ReadByte();
    226 
    227         }
    228         else if (Object.ReferenceEquals(value.GetType(), typeof(byte[])))
     227          }
     228
     229        }
     230        else if (value is byte[])
    229231        {
    230232          keyType = argType.ByteArray;
     
    238240            key[i] = ba[i];
    239241        }
    240         else if (Object.ReferenceEquals(value.GetType(), typeof(string)))
     242        else if (value is string)
    241243        {
    242244          string str = (string) value;
     
    276278          //case argType.Stream:
    277279            {
    278               CryptoolStream saltDataStream = new CryptoolStream();
    279               saltDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, salt);
    280               return saltDataStream;
     280              return new CStreamWriter(salt);
    281281            }
    282282
     
    293293          return;
    294294
    295         if (Object.ReferenceEquals(value.GetType(), typeof(CryptoolStream)))
     295        if (value is ICryptoolStream)
    296296        {
    297297          saltType = argType.Stream;
    298298
    299           CryptoolStream cst = (CryptoolStream)value;
     299          using (CStreamReader cst = ((ICryptoolStream)value).CreateReader())
     300          {
     301              /// FIXME: potentially broken. Shall not rely on Length property to return
     302              /// final value.
    300303          long len = cst.Length;
    301304          salt = new byte[len];
     
    304307            salt[i] = (byte)cst.ReadByte();
    305308        }
    306         else if (Object.ReferenceEquals(value.GetType(), typeof(byte[])))
     309        }
     310        else if (value is byte[])
    307311        {
    308312          saltType = argType.ByteArray;
     
    316320            salt[i] = ba[i];
    317321        }
    318         else if (Object.ReferenceEquals(value.GetType(), typeof(string)))
     322        else if (value is string)
    319323        {
    320324          string str = (string)value;
     
    337341
    338342    // Output
    339     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    340343    private byte[] outputData = { };
    341344
     
    356359    [PropertyInfo(Direction.OutputData, "Hashed Stream", "Output stream of the hashed value", "",
    357360      true, false, QuickWatchFormat.Hex, null)]
    358     public CryptoolStream HashOutputStream
    359     {
    360       get
    361       {
    362         CryptoolStream outputDataStream = null;
    363         if (outputData != null)
    364         {
    365           outputDataStream = new CryptoolStream();
    366           outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    367           listCryptoolStreamsOut.Add(outputDataStream);
    368         }
    369         GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
    370         return outputDataStream;
    371       }
     361    public ICryptoolStream HashOutputStream
     362    {
     363      get
     364      {
     365          return new CStreamWriter(outputData);
     366        }
    372367      //set
    373368      //{
     
    501496    public void Dispose()
    502497    {
    503       foreach (CryptoolStream stream in listCryptoolStreamsOut)
    504       {
    505         stream.Close();
    506       }
    507       listCryptoolStreamsOut.Clear();
    508498      GuiLogMessage("Dispose.", NotificationLevel.Debug);
    509499    }
  • trunk/CrypPlugins/PRESENT/PRESENT.cs

    r2334 r2529  
    4949    private PRESENTSettings settings;
    5050    private PRESENTAnimation presentation;
    51     private CryptoolStream inputStream;
    52     private CryptoolStream outputStream;
     51    private ICryptoolStream inputStream;
     52    private CStreamWriter outputStream;
    5353    private byte[] inputKey;
    5454    private byte[] inputIV;
     
    5656    private CryptoStream p_crypto_stream_dec;
    5757    private bool stop;
    58     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    5958    #endregion
    6059
     
    7574
    7675    [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted.", "", true, false, QuickWatchFormat.Hex, null)]
    77     public CryptoolStream InputStream
     76    public ICryptoolStream InputStream
    7877    {
    7978     
    8079      get
    8180      {
    82         if (inputStream != null)
    83         {
    84           CryptoolStream cs = new CryptoolStream();
    85           cs.OpenRead(inputStream.FileName);
    86           listCryptoolStreamsOut.Add(cs);
    87           return cs;
    88         }
    89         else return null;       
    90       }
     81          return inputStream;
     82        }
    9183     
    9284      set
     
    9587        {
    9688          this.inputStream = value;
    97           if (value != null) listCryptoolStreamsOut.Add(value);
    9889          OnPropertyChanged("InputStream");
    9990        }
     
    134125
    135126    [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", "", true, false, QuickWatchFormat.Hex, null)]
    136     public CryptoolStream OutputStream
     127    public ICryptoolStream OutputStream
    137128    {
    138129     
    139130      get
    140131      {         
    141         if (this.outputStream != null && File.Exists(this.outputStream.FileName))
    142         {
    143           CryptoolStream cs = new CryptoolStream();
    144           listCryptoolStreamsOut.Add(cs);
    145           cs.OpenRead(this.outputStream.FileName);
    146           return cs;
    147         }
    148         if (outputStream != null && !File.Exists(this.outputStream.FileName))
    149           GuiLogMessage("Can't find the created output filename.", NotificationLevel.Error);
    150         return null;
    151       }
     132          return outputStream;
     133        }
    152134     
    153135      set
    154136      {
    155         outputStream = value;
    156         if (value != null) listCryptoolStreamsOut.Add(value);
    157         OnPropertyChanged("OutputStream");
    158137      }
    159138    }
     
    251230        try
    252231        {
    253           if (this.inputStream.CanSeek) this.inputStream.Position = 0;
     232              using (CStreamReader reader = inputStream.CreateReader())
     233              {
    254234          SymmetricAlgorithm p_alg = new PresentManaged();
    255235          ConfigureAlg(p_alg, true);
    256236
    257           if ((this.presentation != null) & (p_alg.KeySize == 80)) {
     237                  if ((this.presentation != null) & (p_alg.KeySize == 80))
     238                  {
    258239              byte[] block = new byte[8];
    259240              byte[] key = (byte[])p_alg.Key.Clone();
    260               int r = InputStream.Read(block, 0, 8);
    261               if (this.inputStream.CanSeek) this.inputStream.Position = 0;
    262               if (r < 8) {
    263                   for (int i = 0; i < r; i++) {
     241                      int r = reader.Read(block, 0, 8);
     242                      if (reader.CanSeek) reader.Position = 0;
     243                      if (r < 8)
     244                      {
     245                          for (int i = 0; i < r; i++)
     246                          {
    264247                      block[7 - i] = block[r - i - 1];
    265248                  }
     
    272255
    273256          ICryptoTransform p_encryptor = p_alg.CreateEncryptor();
    274           outputStream = new CryptoolStream();
    275           listCryptoolStreamsOut.Add(outputStream);
    276           outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     257                  outputStream = new CStreamWriter();
    277258          p_crypto_stream_enc = new CryptoStream((Stream)inputStream, p_encryptor, CryptoStreamMode.Read);
    278259          byte[] buffer = new byte[p_alg.BlockSize / 8];
     
    283264          {
    284265            outputStream.Write(buffer, 0, bytesRead);
    285             if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     266                      if ((int)(reader.Position * 100 / inputStream.Length) > position)
    286267            {
    287               position = (int)(inputStream.Position * 100 / inputStream.Length);
    288               ProgressChanged(inputStream.Position, inputStream.Length);
     268                          position = (int)(reader.Position * 100 / inputStream.Length);
     269                          ProgressChanged(reader.Position, inputStream.Length);
    289270            }
    290271          }
     
    298279          {
    299280            GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
    300             GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
     281                      GuiLogMessage("Wrote data to file: " + outputStream.FilePath, NotificationLevel.Info);
    301282            GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    302283            outputStream.Close();
     
    309290          }
    310291        }
     292          }
    311293        catch (CryptographicException cryptographicException)
    312294        {
     
    336318        try
    337319        {
    338           if (this.inputStream.CanSeek) this.inputStream.Position = 0;
     320              using (CStreamReader reader = this.inputStream.CreateReader())
     321              {
    339322          SymmetricAlgorithm p_alg = new PresentManaged();
    340323          ConfigureAlg(p_alg, false);
    341324          ICryptoTransform p_decryptor = p_alg.CreateDecryptor();
    342           outputStream = new CryptoolStream();
    343           listCryptoolStreamsOut.Add(outputStream);
    344           outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     325                  outputStream = new CStreamWriter();
    345326          p_crypto_stream_dec = new CryptoStream((Stream)inputStream, p_decryptor, CryptoStreamMode.Read);
    346327          byte[] buffer = new byte[p_alg.BlockSize / 8];
     
    351332          {
    352333            outputStream.Write(buffer, 0, bytesRead);
    353             if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     334                      if ((int)(reader.Position * 100 / inputStream.Length) > position)
    354335            {
    355               position = (int)(inputStream.Position * 100 / inputStream.Length);
    356               ProgressChanged(inputStream.Position, inputStream.Length);
     336                          position = (int)(reader.Position * 100 / inputStream.Length);
     337                          ProgressChanged(reader.Position, inputStream.Length);
    357338            }
    358339          }
     
    364345          {
    365346            GuiLogMessage("Decryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
    366             GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
     347                      GuiLogMessage("Wrote data to file: " + outputStream.FilePath, NotificationLevel.Info);
    367348            GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    368349            outputStream.Close();
     
    375356          }
    376357        }
     358          }
    377359        catch (CryptographicException cryptographicException)
    378360        {
     
    428410        inputStream = null;
    429411        outputStream = null;
    430 
    431         foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    432         {
    433           cryptoolStream.Close();
    434         }
    435         listCryptoolStreamsOut.Clear();
    436412
    437413        if (p_crypto_stream_dec != null)
  • trunk/CrypPlugins/PeerToPeer/DHT_CommonManagement.cs

    r1458 r2529  
    7979        /// <param name="cStream">CryptoolStream from the Encryption-PlugIn</param>
    8080        /// <returns></returns>
    81         public static bool SetEncryptedData(ref IP2PControl p2pControl, string sTopicName, CryptoolStream cStream)
     81        public static bool SetEncryptedData(ref IP2PControl p2pControl, string sTopicName, ICryptoolStream cStream)
    8282        {
    8383            bool encryptedTextStored = false;
    84             if (cStream != null && sTopicName != null && sTopicName != String.Empty && p2pControl != null)
     84            if (cStream != null && !string.IsNullOrEmpty(sTopicName) && p2pControl != null)
    8585            {
    86                 var newEncryptedData = new CryptoolStream();
    87                 newEncryptedData.OpenRead(cStream.FileName);
    88                 if (newEncryptedData.CanRead)
     86                using (CStreamReader cReader = cStream.CreateReader())
    8987                {
    9088                    // Convert CryptoolStream to an byte Array and store it in the DHT
    91                     if (newEncryptedData.Length > Int32.MaxValue)
     89                    if (cReader.Length > Int32.MaxValue)
    9290                        throw (new Exception(
    9391                            "Encrypted Data are too long for this PlugIn. The maximum size of Data is " + Int32.MaxValue +
    9492                            "!"));
    95                     var byteEncryptedData = new byte[newEncryptedData.Length];
    96                     int k = newEncryptedData.Read(byteEncryptedData, 0, byteEncryptedData.Length);
    97                     if (k < byteEncryptedData.Length)
     93
     94                    byte[] byteEncryptedData = cReader.ReadFully();
     95                    if (cReader.Length < byteEncryptedData.Length)
    9896                        throw (new Exception("Read Data are shorter than byteArrayLen"));
    9997                    encryptedTextStored = p2pControl.DHTstore(sTopicName + EncryptedData, byteEncryptedData);
    10098                }
    101                 else
    102                 {
    103                     throw (new Exception("Reading the CryptoolStream wasn't possible"));
     99
    104100                }
    105             }
    106101            return encryptedTextStored;
    107102        }
  • trunk/CrypPlugins/Playfair/Playfair.cs

    r2334 r2529  
    4343        private string preFormatedInputString;
    4444        private int matrixSize;
    45         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4645
    4746        #endregion
     
    6867
    6968        [PropertyInfo(Direction.OutputData,"Stream output","The string after processing with the Playfair cipher is converted to a stream. Default encoding is used.","",false,false,QuickWatchFormat.Text, null)]
    70         public CryptoolStream OutputData
     69        public ICryptoolStream OutputData
    7170        {
    7271            get
     
    7473                if (outputString != null)
    7574                {
    76                     CryptoolStream cs = new CryptoolStream();
    77                     listCryptoolStreamsOut.Add(cs);
    78                     cs.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(outputString.ToCharArray()));
    79                     return cs;
     75                    return new CStreamWriter(Encoding.Default.GetBytes(outputString));
    8076                }
    8177                else
     
    259255        public void Dispose()
    260256        {
    261             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    262             {
    263                 stream.Close();
    264             }
    265             listCryptoolStreamsOut.Clear();
    266         }
     257            }
    267258
    268259        public bool HasChanges
  • trunk/CrypPlugins/RC2/RC2.cs

    r2334 r2529  
    3636        #region Private variables
    3737        private RC2Settings settings;
    38         private CryptoolStream inputStream;
    39         private CryptoolStream outputStream;
     38        private ICryptoolStream inputStream;
     39        private CStreamWriter outputStreamWriter;
    4040        private byte[] inputKey;
    4141        private byte[] inputIV;
    4242        private CryptoStream p_crypto_stream;
    4343        private bool stop = false;
    44         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4544        #endregion
    4645
     
    6362
    6463        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", "", true, false,QuickWatchFormat.Hex, null)]
    65         public CryptoolStream InputStream
     64        public ICryptoolStream InputStream
    6665        {
    6766            get
    6867            {
    69                 if (inputStream != null)
    70                 {
    71                     CryptoolStream cs = new CryptoolStream();
    72                     cs.OpenRead(inputStream.FileName);
    73                     listCryptoolStreamsOut.Add(cs);
    74                     return cs;
    75                 }
    76                 else return null;
    77             }
     68                return inputStream;
     69                }
    7870            set
    7971            {
    8072                this.inputStream = value;
    81                 if (value != null) listCryptoolStreamsOut.Add(value);
    82                 OnPropertyChanged("InputStream");
     73
     74                //wander 20100427: unnecessary, event should've been propagated by editor
     75                //OnPropertyChanged("InputStream");
    8376            }
    8477        }
     
    107100
    108101        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", null, true, false,QuickWatchFormat.Hex, null)]
    109         public CryptoolStream OutputStream
     102        public ICryptoolStream OutputStream
    110103        {
    111104            get
    112105            {
    113                 if (this.outputStream != null)
    114                 {
    115                     CryptoolStream cs = new CryptoolStream();
    116                     listCryptoolStreamsOut.Add(cs);
    117                     cs.OpenRead(this.outputStream.FileName);
    118                     return cs;
    119                 }
    120                 return null;
    121             }
     106                return outputStreamWriter;
     107                }
    122108            set
    123109            {
    124                 outputStream = value;
    125                 if (value != null) listCryptoolStreamsOut.Add(value);
    126                 OnPropertyChanged("OutputStream");
     110                //wander 20100427: unnecessary, propagated by Execute()
     111                //OnPropertyChanged("OutputStream");
    127112            }
    128113        }
     
    172157                //create some input
    173158                String dummystring = "Dummy string - no input provided - \"Hello RC2 World\" - dummy string - no input provided!";
    174                 this.inputStream = new CryptoolStream();
    175                 this.inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
     159                this.inputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring));
    176160                // write a warning to the ouside word
    177161                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     
    190174            {
    191175                checkForInputStream();
    192                 if (inputStream == null || (inputStream != null && inputStream.Length == 0))
     176                if (inputStream == null || inputStream.Length == 0)
    193177                {
    194178                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    196180                }
    197181
    198                 if (this.inputStream.CanSeek) this.inputStream.Position = 0;
     182                using (CStreamReader reader = inputStream.CreateReader())
     183                {
    199184                SymmetricAlgorithm p_alg = new RC2CryptoServiceProvider();
    200185
     
    212197                }
    213198
    214                 outputStream = new CryptoolStream();
    215                 listCryptoolStreamsOut.Add(outputStream);
    216                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     199                    outputStreamWriter = new CStreamWriter();
    217200                p_crypto_stream = new CryptoStream((Stream)inputStream, p_encryptor, CryptoStreamMode.Read);
    218201                byte[] buffer = new byte[p_alg.BlockSize / 8];
     
    223206                while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
    224207                {
    225                     outputStream.Write(buffer, 0, bytesRead);
    226 
    227                     if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     208                        outputStreamWriter.Write(buffer, 0, bytesRead);
     209
     210                        if ((int)(reader.Position * 100 / reader.Length) > position)
    228211                    {
    229                         position = (int)(inputStream.Position * 100 / inputStream.Length);
    230                         ProgressChanged(inputStream.Position, inputStream.Length);
     212                            position = (int)(reader.Position * 100 / reader.Length);
     213                            ProgressChanged(reader.Position, reader.Length);
    231214                    }
    232215                }
    233216                p_crypto_stream.Flush();
    234217                // p_crypto_stream.Close();
    235                 outputStream.Close();
     218                    outputStreamWriter.Close();
    236219                DateTime stopTime = DateTime.Now;
    237220                TimeSpan duration = stopTime - startTime;
     
    239222                if (!stop)
    240223                {
    241                     GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
    242                     GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
     224                        GuiLogMessage("Encryption complete! (in: " + reader.Length.ToString() + " bytes, out: " + outputStreamWriter.Length.ToString() + " bytes)", NotificationLevel.Info);
    243225                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    244226                    OnPropertyChanged("OutputStream");
     
    248230                    GuiLogMessage("Aborted!", NotificationLevel.Info);
    249231                }
     232            }
    250233            }
    251234            catch (CryptographicException cryptographicException)
     
    304287                inputIV = null;
    305288                inputStream = null;
    306                 outputStream = null;
    307 
    308                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    309                 {
    310                     stream.Close();
    311                 }
    312                 listCryptoolStreamsOut.Clear();
     289                outputStreamWriter = null;
    313290
    314291                if (p_crypto_stream != null)
  • trunk/CrypPlugins/RIPEMD160/RIPEMD160.cs

    r2334 r2529  
    3838        #region Private variables
    3939        private RIPEMD160Settings settings;
    40         private CryptoolStream inputData;
    41         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     40        private ICryptoolStream inputData;
    4241        private byte[] outputData;
    4342        #endregion
     
    5756        // [QuickWatch(QuickWatchFormat.Hex, null)]
    5857        [PropertyInfo(Direction.InputData, "Input stream", "Input data to be hashed", "", true, false, QuickWatchFormat.Hex, null)]
    59         public CryptoolStream InputData
     58        public ICryptoolStream InputData
    6059        {
    6160            get
    6261            {
    63               if (this.inputData != null)
    64               {
    65                 CryptoolStream cs = new CryptoolStream();
    66                 listCryptoolStreamsOut.Add(cs);
    67                 cs.OpenRead(inputData.FileName);
    68                 return cs;
     62                return inputData;
    6963              }
    70               return null;
    71             }
    7264            set
    7365            {
     
    8274        // [QuickWatch(QuickWatchFormat.Hex, null)]
    8375        [PropertyInfo(Direction.OutputData, "Hashed value", "Output data of the hashed value as Stream", "", true, false, QuickWatchFormat.Hex, null)]
    84         public CryptoolStream OutputDataStream
     76        public ICryptoolStream OutputDataStream
    8577        {
    8678          get
    8779          {
    88               CryptoolStream outputDataStream = null;
    8980              if (OutputData != null)
    9081              {
    91                 outputDataStream = new CryptoolStream();
    92                 outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, OutputData);
    93                 listCryptoolStreamsOut.Add(outputDataStream);
     82                  return new CStreamWriter(outputData);
    9483              }
    95               return outputDataStream;
     84              return null;
    9685          }
    9786          set { } // readonly
     
    120109          {
    121110            System.Security.Cryptography.RIPEMD160 ripeMd160Hash = System.Security.Cryptography.RIPEMD160.Create();
    122             byte[] data = ripeMd160Hash.ComputeHash((Stream)inputData);
    123 
    124            
     111            using (CStreamReader reader = inputData.CreateReader())
     112            {
     113                OutputData = ripeMd160Hash.ComputeHash(reader);
     114            }
     115
    125116            GuiLogMessage("Hash created.", NotificationLevel.Info);           
    126117            Progress(1, 1);
    127 
    128             OutputData = data;
    129118          }
    130119          else
     
    144133        public void Dispose()
    145134        {
    146           if (inputData != null)
    147           {
    148             inputData.Close();
    149135            inputData = null;
    150136          }
    151           foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    152           {
    153             cryptoolStream.Close();
    154           }
    155           listCryptoolStreamsOut.Clear();
    156         }
    157137        #endregion
    158138
  • trunk/CrypPlugins/RandomInput/RandomInput.cs

    r2334 r2529  
    4545    private RandomInputSettings settings;
    4646    private RNGCryptoServiceProvider sRandom = new RNGCryptoServiceProvider();
    47     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4847
    4948    public ISettings Settings
     
    8584
    8685    [PropertyInfo(Direction.OutputData, "Stream Output", "Memory stream of given length.", "", false, false, QuickWatchFormat.Hex, null)]
    87     public CryptoolStream StreamOutput
     86    public ICryptoolStream StreamOutput
    8887    {
    8988      get
     
    9493        if (rndArray != null)
    9594        {
     95           
    9696          GuiMessage("Send " + rndArray.Length + " bytes of random data as stream.", NotificationLevel.Debug);
    97           CryptoolStream cryptoolStream = new CryptoolStream();
    98           cryptoolStream.OpenRead(this.GetPluginInfoAttribute().Caption, rndArray);
    99           listCryptoolStreamsOut.Add(cryptoolStream);         
    10097          Progress(1.0, 1.0);
    101          
    102           return cryptoolStream;
     98          return new CStreamWriter(rndArray);
    10399        }
    104100        GuiMessage("No stream generated. Returning null.", NotificationLevel.Error);
     
    141137    public void Dispose()
    142138    {
    143       foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    144       {
    145         cryptoolStream.Close();
    146       }
    147       listCryptoolStreamsOut.Clear();
    148     }
     139      }
    149140
    150141    public void Stop()
     
    182173    {
    183174      getRand();
     175      Progress(1.0, 1.0);
    184176    }
    185177
  • trunk/CrypPlugins/SDES/SDES.cs

    r2334 r2529  
    4646
    4747        private SDESSettings settings;
    48         private CryptoolStream inputStream;
    49         private CryptoolStream outputStream;
    50         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
     48        private ICryptoolStream inputStream;
     49        private CStreamWriter outputStream;
    5150        private byte[] inputKey;
    5251        private byte[] inputIV;       
     
    116115        /// </summary>
    117116        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", null, true, false, QuickWatchFormat.Hex, null)]
    118         public CryptoolStream InputStream
     117        public ICryptoolStream InputStream
    119118        {
    120119            get
    121120            {
    122                 try
    123                 {
    124                     if (inputStream != null)
    125                     {
    126                         CryptoolStream cs = new CryptoolStream();
    127                         cs.OpenRead(inputStream.FileName);
    128                         listCryptoolStreamsOut.Add(cs);
    129                         return cs;
    130                     }
    131                     else return null;
    132                 }
    133                 catch (Exception ex)
    134                 {
    135                     GuiLogMessage("getInputStream: " + ex.Message, NotificationLevel.Error);
    136                     return null;
    137                 }
    138 
    139             }
     121                return inputStream;
     122                    }
    140123            set
    141124            {
    142125                this.inputStream = value;
    143                 if (value != null)
    144                 {
    145                     listCryptoolStreamsOut.Add(value);                     
    146                 }
    147126                OnPropertyChanged("InputStream");
    148127            }
     
    153132        /// </summary>
    154133        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", null, true, false, QuickWatchFormat.Hex, null)]
    155         public CryptoolStream OutputStream
     134        public ICryptoolStream OutputStream
    156135        {
    157136            get
    158137            {
    159                 try
    160                 {
    161                     if (this.outputStream != null)
    162                     {
    163                         CryptoolStream cs = new CryptoolStream();
    164                         listCryptoolStreamsOut.Add(cs);
    165                         cs.OpenRead(this.outputStream.FileName);
    166                         return cs;
    167                     }
    168                     return null;
    169                 }
    170                 catch (Exception ex)
    171                 {
    172                     GuiLogMessage("getOutputStream: " + ex.Message, NotificationLevel.Error);
    173                     return null;
    174                 }
    175             }
     138                return outputStream;
     139                    }
    176140            set
    177141            {
    178 
    179                 this.outputStream = value;
    180                 if (value != null)
    181                 {
    182                     listCryptoolStreamsOut.Add(value);
    183                 }
    184                 OnPropertyChanged("OutputStream");
    185             }
    186         }
     142                }
     143            }
    187144
    188145        /// <summary>
     
    277234                inputIV = null;
    278235
    279                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    280                 {
    281                     stream.Close();
    282                 }
    283                 listCryptoolStreamsOut.Clear();
    284 
     236                if (outputStream != null)
     237                {
     238                    outputStream.Close();
     239                    outputStream.Dispose();
     240                    outputStream = null;
     241                }
    285242            }
    286243            catch (Exception ex)
     
    384341        private void checkForInputStream()
    385342        {
    386             if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
     343            if (settings.Action == 0 && (inputStream == null || inputStream.Length == 0))
    387344            {
    388345                //create some input
    389346                String dummystring = "Dummy string - no input provided - \"Hello SDES World\" - dummy string - no input provided!";
    390                 this.inputStream = new CryptoolStream();
    391                 this.inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
     347                this.inputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring));
    392348                // write a warning to the ouside word
    393349                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     
    454410                }
    455411
    456                 if (inputStream == null || (inputStream != null && inputStream.Length == 0))
     412                if (inputStream == null)
    457413                {
    458414                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    460416                }
    461417
    462                 if (this.inputStream.CanSeek) this.inputStream.Position = 0;
    463                
    464                 outputStream = new CryptoolStream();
    465                 listCryptoolStreamsOut.Add(outputStream);
    466                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
     418                using (CStreamReader reader = inputStream.CreateReader())
     419                {
     420                    outputStream = new CStreamWriter();
     421                    OnPropertyChanged("OutputStream");
    467422               
    468423                System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();               
     
    470425
    471426                //Encrypt
    472                 if(action == 0){
     427                    if (action == 0)
     428                    {
    473429                   
    474430                    if (this.settings.Mode == 0)
     
    476432                        GuiLogMessage("Starting encryption with ecb", NotificationLevel.Info);
    477433                        ElectronicCodeBook ecb = new ElectronicCodeBook(this);
    478                         ecb.encrypt(inputStream, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)));
     434                            ecb.encrypt(reader, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)));
    479435                    }
    480436                    else if (this.settings.Mode == 1)
     
    482438                        GuiLogMessage("Starting encryption with cbc", NotificationLevel.Info);
    483439                        CipherBlockChaining cbc = new CipherBlockChaining(this);
    484                         cbc.encrypt(inputStream, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)), Tools.stringToBinaryByteArray(enc.GetString(this.inputIV)));
     440                            cbc.encrypt(reader, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)), Tools.stringToBinaryByteArray(enc.GetString(this.inputIV)));
    485441                    }
    486442                }
     
    493449                        GuiLogMessage("Starting decryption with ecb", NotificationLevel.Info);
    494450                        ElectronicCodeBook ecb = new ElectronicCodeBook(this);
    495                         ecb.decrypt(inputStream, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)));
     451                            ecb.decrypt(reader, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)));
    496452                    }
    497453                    if (this.settings.Mode == 1)
     
    499455                        GuiLogMessage("Starting decryption with cbc", NotificationLevel.Info);
    500456                        CipherBlockChaining cbc = new CipherBlockChaining(this);
    501                         cbc.decrypt(inputStream, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)), Tools.stringToBinaryByteArray(enc.GetString(this.inputIV)));
     457                            cbc.decrypt(reader, outputStream, Tools.stringToBinaryByteArray(enc.GetString(this.inputKey)), Tools.stringToBinaryByteArray(enc.GetString(this.inputIV)));
    502458                    }
    503459                }
     
    508464                {
    509465                    GuiLogMessage("En-/Decryption complete! ", NotificationLevel.Info);
    510                     GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
    511466                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    512467                    OnPropertyChanged("OutputStream");
    513468               
    514                 }else{                   
     469                    }
     470                    else
     471                    {
    515472                    GuiLogMessage("Aborted!", NotificationLevel.Info);
    516473                }
    517474
    518                 //avoid unnecessary error messages because of wrong input/output streams:
    519                 outputStream.Flush();
    520475                outputStream.Close();
    521                 inputStream.Close();               
     476                    reader.Close();
     477            }
    522478            }
    523479            catch (Exception exception)
     
    704660               
    705661                int i = 0;
    706                 CryptoolStream inputstream = plugin.InputStream;
    707                 while ((inputstream.Read(buffer, 0, 1)) > 0 && i < bytesToUse)
    708                 {
     662                using (CStreamReader reader = plugin.InputStream.CreateReader())
     663                {
     664                    while ((reader.Read(buffer, 0, 1)) > 0 && i < bytesToUse)
     665                    {
    709666                    input[i] = buffer[0];
    710667                    i++;
    711668                }
     669            }
    712670            }
    713671
     
    18731831        ///using CipherBlockChaining
    18741832        ///</summary>
    1875         public void encrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key, byte[] vector)
     1833        public void encrypt(CStreamReader reader, CStreamWriter writer, byte[] key, byte[] vector)
    18761834        {
    18771835
     
    18791837            int position = 0;
    18801838
    1881             while (!this.mSdes.getStop() && (inputstream.Read(buffer, 0, 1)) > 0)
     1839            while (!this.mSdes.getStop() && (reader.Read(buffer, 0, 1)) > 0)
    18821840            {
    18831841                //Step 1 get plaintext symbol
     
    18881846                vector = mAlgorithm.encrypt(vector, key);
    18891847                //Step 4 store symbol in ciphertext
    1890                 outputstream.Write(Tools.byteArrayToByte(vector));
    1891 
    1892                 if ((int)(inputstream.Position * 100 / inputstream.Length) > position)
    1893                 {
    1894                     position = (int)(inputstream.Position * 100 / inputstream.Length);
    1895                     mSdes.ProgressChanged(inputstream.Position, inputstream.Length);
    1896                 }
    1897                 outputstream.Flush();
     1848                writer.WriteByte(Tools.byteArrayToByte(vector));
     1849
     1850                if ((int)(reader.Position * 100 / reader.Length) > position)
     1851                {
     1852                    position = (int)(reader.Position * 100 / reader.Length);
     1853                    mSdes.ProgressChanged(reader.Position, reader.Length);
     1854                }
     1855                writer.Flush();
    18981856            }
    18991857
     
    19311889        ///using CipherBlockChaining
    19321890        ///</summary>
    1933         public void decrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key, byte[] vector)
     1891        public void decrypt(CStreamReader reader, CStreamWriter writer, byte[] key, byte[] vector)
    19341892        {
    19351893
     
    19371895            int position = 0;
    19381896
    1939             while (!this.mSdes.getStop() && (inputstream.Read(buffer, 0, 1)) > 0)
     1897            while (!this.mSdes.getStop() && (reader.Read(buffer, 0, 1)) > 0)
    19401898            {
    19411899                //Step 1 get Symbol of Ciphertext
    19421900                byte symbol = buffer[0];
    19431901                //Step 2 Decrypt symbol with key and exclusiv-or with vector
    1944                 outputstream.Write((Tools.byteArrayToByte(Tools.exclusive_or(mAlgorithm.decrypt(Tools.byteToByteArray(symbol), key), vector))));
     1902                writer.WriteByte((Tools.byteArrayToByte(Tools.exclusive_or(mAlgorithm.decrypt(Tools.byteToByteArray(symbol), key), vector))));
    19451903                //Step 3 let vector be the decrypted Symbol
    19461904                vector = Tools.byteToByteArray(buffer[0]);
    19471905
    1948                 if ((int)(inputstream.Position * 100 / inputstream.Length) > position)
    1949                 {
    1950                     position = (int)(inputstream.Position * 100 / inputstream.Length);
    1951                     mSdes.ProgressChanged(inputstream.Position, inputstream.Length);
    1952                 }
    1953                 outputstream.Flush();
     1906                if ((int)(reader.Position * 100 / reader.Length) > position)
     1907                {
     1908                    position = (int)(reader.Position * 100 / reader.Length);
     1909                    mSdes.ProgressChanged(reader.Position, reader.Length);
     1910                }
     1911                writer.Flush();
    19541912            }
    19551913
     
    20081966        ///using ElectronicCodeBookMode
    20091967        ///
    2010         public void encrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key)
     1968        public void encrypt(CStreamReader reader, CStreamWriter writer, byte[] key)
    20111969        {
    20121970
     
    20141972            int position = 0;
    20151973
    2016             while (!this.mSdes.getStop() && (inputstream.Read(buffer, 0, 1)) > 0)
     1974            while (!this.mSdes.getStop() && (reader.Read(buffer, 0, 1)) > 0)
    20171975            {
    20181976                //Step 1 get plaintext symbol
    20191977                byte symbol = buffer[0]; ;
    20201978                //Step 2 encrypt symbol
    2021                 outputstream.Write(Tools.byteArrayToByte(this.mAlgorithm.encrypt(Tools.byteToByteArray(symbol), key)));
    2022 
    2023                 if ((int)(inputstream.Position * 100 / inputstream.Length) > position)
    2024                 {
    2025                     position = (int)(inputstream.Position * 100 / inputstream.Length);
    2026                     mSdes.ProgressChanged(inputstream.Position, inputstream.Length);
    2027                 }
    2028                 outputstream.Flush();
     1979                writer.WriteByte(Tools.byteArrayToByte(this.mAlgorithm.encrypt(Tools.byteToByteArray(symbol), key)));
     1980
     1981                if ((int)(reader.Position * 100 / reader.Length) > position)
     1982                {
     1983                    position = (int)(reader.Position * 100 / reader.Length);
     1984                    mSdes.ProgressChanged(reader.Position, reader.Length);
     1985                }
     1986                writer.Flush();
    20291987
    20301988            }//end while
     
    20632021        ///using ElectronicCodeBook mode
    20642022        ///</summary>
    2065         public void decrypt(CryptoolStream inputstream, CryptoolStream outputstream, byte[] key)
     2023        public void decrypt(CStreamReader reader, CStreamWriter writer, byte[] key)
    20662024        {
    20672025
     
    20692027            int position = 0;
    20702028
    2071             while (!this.mSdes.getStop() && (inputstream.Read(buffer, 0, 1)) > 0)
     2029            while (!this.mSdes.getStop() && (reader.Read(buffer, 0, 1)) > 0)
    20722030            {
    20732031                //Step 1 get plaintext symbol
    20742032                byte symbol = buffer[0];
    20752033                //Step 2 encrypt symbol
    2076                 outputstream.Write(Tools.byteArrayToByte(this.mAlgorithm.decrypt(Tools.byteToByteArray(symbol), key)));
    2077 
    2078                 if ((int)(inputstream.Position * 100 / inputstream.Length) > position)
    2079                 {
    2080                     position = (int)(inputstream.Position * 100 / inputstream.Length);
    2081                     mSdes.ProgressChanged(inputstream.Position, inputstream.Length);
    2082                 }
    2083                 outputstream.Flush();
     2034                writer.WriteByte(Tools.byteArrayToByte(this.mAlgorithm.decrypt(Tools.byteToByteArray(symbol), key)));
     2035
     2036                if ((int)(reader.Position * 100 / reader.Length) > position)
     2037                {
     2038                    position = (int)(reader.Position * 100 / reader.Length);
     2039                    mSdes.ProgressChanged(reader.Position, reader.Length);
     2040                }
     2041                writer.Flush();
    20842042
    20852043            }//end while
  • trunk/CrypPlugins/SHA/SHA.cs

    r2334 r2529  
    3636    public class SHA : ICryptographicHash
    3737    {
    38         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    3938        private SHASettings settings;
    40         private CryptoolStream inputData;
     39        private ICryptoolStream inputData;
    4140        private byte[] outputData;       
    4241       
     
    5251        {
    5352            Progress(0.5, 1.0);
    54             if (inputData != null)
    55             {
    56               byte[] data = null;
    57 
    58               switch (settings.SHAFunction)
     53
     54            HashAlgorithm hash = GetHashAlgorithm(settings.SHAFunction);
     55
     56            if (inputData == null)
    5957              {
    60                 case (int)SHASettings.ShaFunction.SHA1:
    61                   SHA1Managed sha1Hash = new SHA1Managed();
    62                   data = sha1Hash.ComputeHash((Stream)inputData);
    63                   break;
    64                 case (int)SHASettings.ShaFunction.SHA256:
    65                   SHA256Managed sha256Hash = new SHA256Managed();
    66                   data = sha256Hash.ComputeHash((Stream)inputData);
    67                   break;
    68                 case (int)SHASettings.ShaFunction.SHA384:
    69                   SHA384Managed sha384Hash = new SHA384Managed();
    70                   data = sha384Hash.ComputeHash((Stream)inputData);
    71                   break;
    72                 case (int)SHASettings.ShaFunction.SHA512:
    73                   SHA512Managed sha512Hash = new SHA512Managed();
    74                   data = sha512Hash.ComputeHash((Stream)inputData);
    75                   break;
     58                GuiLogMessage("Received null value for ICryptoolStream.", NotificationLevel.Warning);
    7659              }             
    77              
    78               GuiLogMessage("Hash created.", NotificationLevel.Info);             
    79               Progress(1, 1);
    80 
    81               OutputData = data;
     60            else if (hash == null)
     61            {
     62                GuiLogMessage("No valid SHA algorithm instance.", NotificationLevel.Error);
    8263            }
    8364            else
    8465            {                           
    85               GuiLogMessage("Received null value for ICryptoolStream.", NotificationLevel.Warning);
     66                using (CStreamReader reader = inputData.CreateReader())
     67                {
     68                    OutputData = hash.ComputeHash(reader);
     69                    GuiLogMessage("Hash created.", NotificationLevel.Info);
     70            }
    8671            }
    8772            Progress(1.0, 1.0);
     73        }
     74
     75        private HashAlgorithm GetHashAlgorithm(int shaType)
     76        {
     77            switch ((SHASettings.ShaFunction)shaType)
     78            {
     79                case SHASettings.ShaFunction.SHA1:
     80                    return new SHA1Managed();
     81                case SHASettings.ShaFunction.SHA256:
     82                    return new SHA1Managed();
     83                case SHASettings.ShaFunction.SHA384:
     84                    return new SHA384Managed();
     85                case SHASettings.ShaFunction.SHA512:
     86                    return new SHA512Managed();
     87            }
     88
     89            return null;
    8890        }
    8991
     
    9799
    98100        [PropertyInfo(Direction.InputData, "Input stream", "Input data to be hashed", "", true, false, QuickWatchFormat.Hex, null)]
    99         public CryptoolStream InputData
     101        public ICryptoolStream InputData
    100102        {
    101103            get
    102104            {
    103               if (inputData != null)
    104               {
    105                 CryptoolStream cs = new CryptoolStream();
    106                 listCryptoolStreamsOut.Add(cs);
    107                 cs.OpenRead(inputData.FileName);
    108                 return cs;
     105                return inputData;
    109106              }
    110               return null;
    111             }
    112107            set
    113108            {
     
    120115
    121116        [PropertyInfo(Direction.OutputData, "Hashed value", "Output data of the hashed value as Stream", "", true, false, QuickWatchFormat.Hex, null)]
    122         public CryptoolStream OutputDataStream
     117        public ICryptoolStream OutputDataStream
    123118        {
    124119            get
    125120            {
    126                 CryptoolStream outputDataStream = null;
    127121                if (outputData != null)
    128122                {
    129                   outputDataStream = new CryptoolStream();
    130                   outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    131                   listCryptoolStreamsOut.Add(outputDataStream);
     123                    return new CStreamWriter(outputData);
    132124                }
    133                 return outputDataStream;
     125                return null;
    134126            }
    135127            set { } //readonly
     
    157149          if (inputData != null)
    158150          {
    159             inputData.Close();
    160151            inputData = null;
    161152          }
    162           foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    163           {
    164             cryptoolStream.Close();
    165153          }
    166           listCryptoolStreamsOut.Clear();
    167         }
    168154
    169155        public void Initialize()
  • trunk/CrypPlugins/SZ42/Lorenz.cs

    r2334 r2529  
    4343        private bool first = true;
    4444        private bool isPlayMode = false;
    45         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4645        private SZ42 sz42Encrypt, sz42Decrypt, reset;
    4746        private BinaryFormatter bf;
     
    266265        public void Dispose()
    267266        {
    268             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    269                 stream.Close();
    270            
    271             listCryptoolStreamsOut.Clear();
    272267        }
    273268
  • trunk/CrypPlugins/Scytale

  • trunk/CrypPlugins/Scytale/Scytale.cs

  • trunk/CrypPlugins/Scytale/Scytale.csproj

  • trunk/CrypPlugins/Scytale/ScytaleSettings.cs

  • trunk/CrypPlugins/StreamComparator/StreamComparator.cs

    r2334 r2529  
    2424    private bool isBinary;
    2525    private bool stop;
    26     private CryptoolStream streamOne;
    27     private CryptoolStream streamTwo;
    28     private List<CryptoolStream> listCryptoolStreams = new List<CryptoolStream>();
     26    private ICryptoolStream streamOne;
     27    private ICryptoolStream streamTwo;
    2928    private StreamComparatorPresentation streamComparatorPresentation;
    3029    #endregion
     
    5049
    5150    [PropertyInfo(Direction.InputData, "Stream one", "First stream to compare", "", true, false, QuickWatchFormat.None, null)]
    52     public CryptoolStream InputOne
     51    public ICryptoolStream InputOne
    5352    {
    5453      get
    5554      {
    56         CryptoolStream cryptoolStream = null;
    57         if (streamOne != null)
    58         {
    59           cryptoolStream = new CryptoolStream();
    60           cryptoolStream.OpenRead(streamOne.FileName);
    61           listCryptoolStreams.Add(cryptoolStream);
    62         }
    63         return cryptoolStream;
    64       }
     55          return streamOne;
     56        }
    6557      set { streamOne = value; }
    6658    }
    6759
    6860    [PropertyInfo(Direction.InputData, "Stream two", "Second stream to compare", "", true, false, QuickWatchFormat.None, null)]
    69     public CryptoolStream InputTwo
     61    public ICryptoolStream InputTwo
    7062    {
    7163      get
    7264      {
    73         CryptoolStream cryptoolStream = null;
    74         if (streamTwo != null)
    75         {
    76           cryptoolStream = new CryptoolStream();
    77           cryptoolStream.OpenRead(streamTwo.FileName);
    78           listCryptoolStreams.Add(cryptoolStream);
    79         }
    80         return cryptoolStream;
    81       }
     65          return streamTwo;
     66        }
    8267      set { streamTwo = value; }
    8368    }
     
    10388      stop = false;
    10489      isBinary = false;
    105 
    106       // this would result in one extra message on each comparison so just set it to false on
    107       // pre-execution
    108       // InputsAreEqual = false;
     90      inputsAreEqual = false;
    10991
    11092      int streamOneByte;
    11193      int streamTwoByte;
    11294
    113       CryptoolStream workingStreamOne = InputOne;
    114       CryptoolStream workingStreamTwo = InputTwo;
    115 
    116       if (workingStreamOne != null && workingStreamTwo != null)
    117       {
    118         if (workingStreamOne == workingStreamTwo || workingStreamOne.FileName == workingStreamTwo.FileName && settings.Diff)
    119         {
    120           GuiTextChanged("Inputs are equal: same file was referenced two times.", NotificationLevel.Info);
    121           InputsAreEqual = true;
    122           if (OnPluginProgressChanged != null) OnPluginProgressChanged(this, new PluginProgressEventArgs(1, 1));
    123           if (settings.Diff) CreateDiffView();         
    124         }
    125         else if (workingStreamOne.Length != workingStreamTwo.Length && !settings.Diff)
    126         {
     95      if (InputOne == null)
     96      {
     97          GuiTextChanged("Stream one is null, no comparison done.", NotificationLevel.Warning);
     98          stop = true;
     99      }
     100      if (InputTwo == null)
     101        {
     102          GuiTextChanged("Stream two is null, no comparison done.", NotificationLevel.Warning);
     103          stop = true;
     104        }
     105
     106      if (stop)
     107          return;
     108
     109      using (CStreamReader readerOne = InputOne.CreateReader(), readerTwo = InputTwo.CreateReader())
     110        {
     111          if (readerOne.Length != readerTwo.Length && !settings.Diff)
     112          {
    127113          GuiTextChanged("Inputs are not equal, because the filesize is different.", NotificationLevel.Info);
    128114          InputsAreEqual = false;
     
    132118        else
    133119        {
    134           workingStreamOne.Position = 0;
    135           workingStreamTwo.Position = 0;
    136120          DateTime startTime = DateTime.Now;
    137121          int position = 0;
     
    143127          {
    144128            // Read one byte from each file.
    145             streamOneByte = workingStreamOne.ReadByte();
    146             streamTwoByte = workingStreamTwo.ReadByte();
     129                  streamOneByte = readerOne.ReadByte();
     130                  streamTwoByte = readerTwo.ReadByte();
    147131
    148132            if (streamOneByte == 0) isBinary = true;
    149133
    150             if (OnPluginProgressChanged != null && workingStreamOne.Length > 0 &&
    151                 (int)(workingStreamOne.Position * 100 / workingStreamOne.Length) > position)
     134                  if (OnPluginProgressChanged != null && readerOne.Length > 0 &&
     135                      (int)(readerOne.Position * 100 / readerOne.Length) > position)
    152136            {
    153               position = (int)(workingStreamOne.Position * 100 / workingStreamOne.Length);
     137                      position = (int)(readerOne.Position * 100 / readerOne.Length);
    154138              OnPluginProgressChanged(this,
    155                 new PluginProgressEventArgs(workingStreamOne.Position, workingStreamOne.Length));
     139                        new PluginProgressEventArgs(readerOne.Position, readerOne.Length));
    156140            }
    157141          } while ((streamOneByte == streamTwoByte) && (streamOneByte != -1));
     
    166150            "Comparison complete. Files are " + (InputsAreEqual ? "equal" : "unequal") + ".", NotificationLevel.Info);
    167151          if (!InputsAreEqual)
    168             GuiTextChanged("First position a different byte: " + workingStreamOne.Position, NotificationLevel.Info);
     152                  GuiTextChanged("First position a different byte: " + readerOne.Position, NotificationLevel.Info);
    169153
    170154          if (OnPluginProgressChanged != null) OnPluginProgressChanged(this, new PluginProgressEventArgs(1, 1));
     
    185169        }
    186170      }
    187       if (workingStreamOne == null)
    188         GuiTextChanged("Stream one is null, no comparison done.", NotificationLevel.Warning);
    189       if (workingStreamTwo == null)
    190         GuiTextChanged("Stream two is null, no comparison done.", NotificationLevel.Warning);
    191171    }
    192172
     
    205185        try
    206186        {
    207           CryptoolStream cryptoolStream = InputOne;
    208           CryptoolStream cryptoolStream2 = InputTwo;
    209 
    210           if (cryptoolStream.Length > maxLength || cryptoolStream2.Length > maxLength)
     187            using (CStreamReader readerOne = InputOne.CreateReader(), readerTwo = InputTwo.CreateReader())
     188            {
     189
     190                if (readerOne.Length > maxLength || readerTwo.Length > maxLength)
    211191            GuiTextChanged("Streams too big for complete diff, reading end of files only.", NotificationLevel.Warning);
    212192
    213193          long startIndex = Math.Max(
    214             cryptoolStream.Length - maxLength,
    215             cryptoolStream2.Length - maxLength);
    216 
    217           StreamReader sr = new StreamReader(cryptoolStream, Encoding.ASCII);         
     194                  readerOne.Length - maxLength,
     195                  readerTwo.Length - maxLength);
     196
     197                StreamReader sr = new StreamReader(readerOne, Encoding.ASCII);
    218198          StringBuilder strTxt1 = new StringBuilder();
    219199
    220           int size = startIndex > 0 ? (int)(cryptoolStream.Length - startIndex) : (int)cryptoolStream.Length;
     200                int size = startIndex > 0 ? (int)(readerOne.Length - startIndex) : (int)readerOne.Length;
    221201          char[] bArr = new char[size];
    222202
     
    224204          sr.Read(bArr, 0, bArr.Length);
    225205          bool test = sr.EndOfStream;
    226           cryptoolStream.Close();
     206                readerOne.Close();
    227207
    228208          for (int i = 0; i < bArr.Length; i++)
    229209            strTxt1.Append(bArr[i]);         
    230210
    231           sr = new StreamReader(cryptoolStream2, Encoding.ASCII);
     211                sr = new StreamReader(readerTwo, Encoding.ASCII);
    232212          if (startIndex > 0) sr.BaseStream.Seek(startIndex, SeekOrigin.Begin);
    233213          StringBuilder strTxt2 = new StringBuilder();
    234214
    235           size = startIndex > 0 ? (int)(cryptoolStream2.Length - startIndex) : (int)cryptoolStream2.Length;
     215                size = startIndex > 0 ? (int)(readerTwo.Length - startIndex) : (int)readerTwo.Length;
    236216          bArr = new char[size];
    237217          sr.Read(bArr, 0, bArr.Length);
    238218          test = sr.EndOfStream;
    239           cryptoolStream2.Close();
     219                readerTwo.Close();
    240220
    241221          for (int i = 0; i < bArr.Length; i++)
     
    263243          result.AppendLine("</Paragraph></TableCell></TableRow>");
    264244         
    265           result.AppendLine("<TableRow Background=\"SkyBlue\"><TableCell ColumnSpan=\"2\" TextAlignment=\"Left\">");
    266           result.AppendLine("<Paragraph FontSize=\"9pt\" FontWeight=\"Bold\">");
    267           result.AppendLine(streamOne.FileName);
    268           result.AppendLine("</Paragraph></TableCell></TableRow>");
    269 
    270           result.AppendLine("<TableRow Background=\"SkyBlue\"><TableCell ColumnSpan=\"2\" TextAlignment=\"Left\">");
    271           result.AppendLine("<Paragraph FontSize=\"9pt\" FontWeight=\"Bold\">");
    272           result.AppendLine(streamTwo.FileName);
    273           result.AppendLine("</Paragraph></TableCell></TableRow>");
    274 
    275 
    276245          int n = 0;
    277246          for (int fdx = 0; fdx < diffItem.Length; fdx++)
     
    313282          result.AppendLine("</TableRowGroup></Table></FlowDocument>");
    314283          StatusBarProgressbarValueChanged(1, 2);
    315           CryptoolStream cs = new CryptoolStream();
    316           cs.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(result.ToString()));
    317           streamComparatorPresentation.SetContent(cs);
     284                CStreamWriter cs = new CStreamWriter(Encoding.Default.GetBytes(result.ToString()));
    318285          cs.Close();
     286                streamComparatorPresentation.SetContent(cs);
    319287          StatusBarProgressbarValueChanged(1, 1);
     288        }
    320289        }
    321290        catch (Exception exception)
     
    429398    public void Dispose()
    430399    {
    431       foreach (CryptoolStream stream in listCryptoolStreams)
    432       {
    433         if (stream != null) stream.Close();
    434       }
    435       listCryptoolStreams.Clear();
    436       if (streamOne != null)
    437       {
    438         this.streamOne.Close();
    439         this.streamOne = null;
    440       }
    441       if (streamTwo != null)
    442       {
    443         this.streamTwo.Close();
    444         this.streamTwo = null;
    445       }
    446     }
     400      }
    447401
    448402    public void Stop()
  • trunk/CrypPlugins/StreamComparator/StreamComparatorPresentation.xaml.cs

    r1259 r2529  
    5252    }
    5353
    54     public void SetContent(CryptoolStream stream)
     54    public void SetContent(ICryptoolStream stream)
    5555    {
    5656      Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     
    5858        try
    5959        {
    60           FlowDocument flowDocumentNew = (FlowDocument)XamlReader.Load((Stream)stream);
     60            using (CStreamReader reader = stream.CreateReader())
     61            {
     62                FlowDocument flowDocumentNew = (FlowDocument)XamlReader.Load(reader);
    6163          documentReader.Document = flowDocumentNew;
     64        }
    6265        }
    6366        catch (Exception ex)
  • trunk/CrypPlugins/StreamToStringConverter/StreamToStringConverter.cs

    r2334 r2529  
    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")]
    73         public CryptoolStream InputStream
     73        public ICryptoolStream InputStream
    7474        {           
    7575            get
    7676            {
    77               CryptoolStream cryptoolStream = null;
    78               if (inputStream != null)
    79               {
    80                 cryptoolStream = new CryptoolStream();
    81                 cryptoolStream.OpenRead(inputStream.FileName);
    82                 listCryptoolStreams.Add(cryptoolStream);               
     77                return inputStream;
    8378              }
    84               return cryptoolStream;
    85             }
    8679            set
    8780            {
    8881              inputStream = value;
    89               if (value != null) listCryptoolStreams.Add(value);
    9082              // processInput(value); This should be done in execute method, because PlayMode causes
    9183              // errors state (yellow/red markers) to be flushed on execute. So if input is processed
     
    124116        public void Dispose()
    125117        {         
    126           if (inputStream != null)
    127           {
    128               inputStream.Flush();
    129               inputStream.Close();
    130118              inputStream = null;
    131119          }
    132           foreach (CryptoolStream cryptoolStream in listCryptoolStreams)
    133           {
    134             cryptoolStream.Close();
    135           }
    136           listCryptoolStreams.Clear();
    137         }
    138120
    139121
     
    173155
    174156        #region Private variables
    175         private List<CryptoolStream> listCryptoolStreams = new List<CryptoolStream>();
    176157        private StreamToStringConverterSettings settings;
    177         private CryptoolStream inputStream = null;
     158        private ICryptoolStream inputStream = null;
    178159        private string outputString;       
    179160        #endregion
     
    181162        #region Private methods
    182163
    183         private void processInput(CryptoolStream value)
    184         {
    185             ShowStatusBarMessage("Got stream input.", NotificationLevel.Debug);       
    186        
    187             if (value != null)
    188             {               
     164        private void processInput(CStreamReader value)
     165        {
    189166                ShowProgress(50, 100);
    190167                ShowStatusBarMessage("Converting input ...", NotificationLevel.Debug);
     
    240217                OnPropertyChanged("OutputString");
    241218            }
    242             else
    243             {
    244                 inputStream = null;
    245                 ShowStatusBarMessage("Stream input is null. Nothing to convert.", NotificationLevel.Warning);
    246             }       
    247         }
    248219
    249220        private string convertBytesToHexString(byte[] array, int start, int count)
     
    288259        public void Execute()
    289260        {
    290           processInput(InputStream);
     261            if (InputStream != null)
     262            {
     263                using (CStreamReader reader = InputStream.CreateReader())
     264                {
     265                    processInput(reader);
     266        }
     267            }
     268            else
     269            {
     270                ShowStatusBarMessage("Stream input is null. Nothing to convert.", NotificationLevel.Warning);
     271            }
    291272        }
    292273
  • trunk/CrypPlugins/StringToStreamConvertor/StringToStreamConverter.cs

    r2334 r2529  
    6161
    6262        [PropertyInfo(Direction.OutputData, "Stream output", "The stream after encoding the text from the input.", "", true, false, QuickWatchFormat.Text, "OutputStreamQuickWatchConverter")]
    63         public CryptoolStream OutputStream
     63        public ICryptoolStream OutputStream
    6464        {
    6565            [MethodImpl(MethodImplOptions.Synchronized)]
    6666            get
    6767            {
    68               if (outputStream != null)
    69               {
    70                 CryptoolStream cs = new CryptoolStream();
    71                 cs.OpenRead(outputStream.FileName);
    72                 listCryptoolStreamsOut.Add(cs);
    73                 return cs;
    74               }
     68                if (outputStream == null)
    7569              return null;
     70
     71                return outputStream;
    7672            }
    7773            set
     
    8682            get
    8783            {
    88                 if (outputBytes != null)
    89                 {
     84                if (outputBytes == null)
     85                    return null;
     86
    9087                    return outputBytes;
    9188                }
    92                 return null;
    93             }
    9489            set
    9590            {
     
    144139                outputStream.Flush();
    145140                outputStream.Close();
     141                outputStream.Dispose();
    146142                outputStream = null;
    147143            }
    148             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    149             {
    150               stream.Close();
    151             }
    152             listCryptoolStreamsOut.Clear();
    153         }
     144            }
    154145
    155146
     
    164155        public void PostExecution()
    165156        {
    166             Dispose();
    167157        }
    168158
    169159        public void PreExecution()
    170160        {
    171             outputStream = null;
    172161        }
    173162
     
    186175
    187176        #region Private variables
    188         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    189177        private StringToStreamConverterSettings settings;
    190         private CryptoolStream outputStream = null;
     178        private CStreamWriter outputStream = null;
    191179        private byte[] outputBytes = null;
    192180        private string inputString;
     
    197185        private void processInput(string value)
    198186        {
    199             ShowStatusBarMessage("Got string input..", NotificationLevel.Debug);
    200        
    201             if ((value != null) && (value.Length != 0))
    202             {               
    203187                ShowProgress(50, 100);
    204188                ShowStatusBarMessage("Converting input ...", NotificationLevel.Debug);
    205                 outputStream = new CryptoolStream();
    206                 listCryptoolStreamsOut.Add(outputStream);
    207189               
    208190                // here conversion happens
     
    211193                    case StringToStreamConverterSettings.EncodingTypes.Default:
    212194                        outputBytes = Encoding.Default.GetBytes(value);
    213                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     195                    outputStream = new CStreamWriter(outputBytes);
    214196                        break;
    215197                    case StringToStreamConverterSettings.EncodingTypes.Base64Binary:
     
    217199                        {
    218200                            outputBytes = Convert.FromBase64String(value);
    219                             outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     201                        outputStream = new CStreamWriter(outputBytes);
    220202                        }
    221203                        catch (Exception ex)
     
    230212                        {
    231213                            outputBytes = convertHexStringToByteArray(value);
    232                             outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     214                        outputStream = new CStreamWriter(outputBytes);
    233215                        }
    234216                        catch (Exception ex)
     
    242224                        {
    243225                            outputBytes = convertOctalStringToByteArray(value);
    244                             outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     226                        outputStream = new CStreamWriter(outputBytes);
    245227                        }
    246228                        catch (Exception ex)
     
    252234                    case StringToStreamConverterSettings.EncodingTypes.Unicode:
    253235                        outputBytes = Encoding.Unicode.GetBytes(value);
    254                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     236                    outputStream = new CStreamWriter(outputBytes);
    255237                        break;
    256238                    case StringToStreamConverterSettings.EncodingTypes.UTF7:
    257239                        outputBytes = Encoding.UTF7.GetBytes(value);
    258                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     240                    outputStream = new CStreamWriter(outputBytes);
    259241                        break;
    260242                    case StringToStreamConverterSettings.EncodingTypes.UTF8:
    261243                        outputBytes = Encoding.UTF8.GetBytes(value);
    262                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     244                    outputStream = new CStreamWriter(outputBytes);
    263245                        break;
    264246                    case StringToStreamConverterSettings.EncodingTypes.UTF32:
    265247                        outputBytes = Encoding.UTF32.GetBytes(value);
    266                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     248                    outputStream = new CStreamWriter(outputBytes);
    267249                        break;
    268250                    case StringToStreamConverterSettings.EncodingTypes.ASCII:
    269251                        outputBytes = Encoding.ASCII.GetBytes(value);
    270                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     252                    outputStream = new CStreamWriter(outputBytes);
    271253                        break;
    272254                    case StringToStreamConverterSettings.EncodingTypes.BigEndianUnicode:
    273255                        outputBytes = Encoding.BigEndianUnicode.GetBytes(value);
    274                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     256                    outputStream = new CStreamWriter(outputBytes);
    275257                        break;
    276258                    default:
    277259                        outputBytes = Encoding.Default.GetBytes(value);
    278                         outputStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputBytes);
     260                    outputStream = new CStreamWriter(outputBytes);
    279261                        break;
    280262                }
     
    286268                OnPropertyChanged("OutputStream");
    287269            }
    288             else
    289             {
    290                 inputString = null;
    291                 outputStream = null;
    292                 outputBytes = null;
    293                 ShowStatusBarMessage("String input is empty. Nothing to convert.", NotificationLevel.Warning);
    294             }
    295270       
    296         }
    297 
    298271
    299272        private byte[] convertHexStringToByteArray(String hexString)
     
    373346        public void Execute()
    374347        {
     348            if ((InputText != null) && (InputText.Length != 0))
     349            {
    375350          processInput(InputText);
     351        }
     352            else
     353            {
     354                ShowStatusBarMessage("String input is empty. Nothing to convert.", NotificationLevel.Warning);
     355            }
    376356        }
    377357
  • trunk/CrypPlugins/SubByteArray/SubByteArray.cs

    r2334 r2529  
    3939
    4040        private byte[] outputData;
    41         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4241
    4342        #endregion
  • trunk/CrypPlugins/Substitution/Substitution.cs

    r2334 r2529  
    4040        private string inputString;
    4141        private string outputString;
    42         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4342
    4443        #endregion
     
    6564
    6665        [PropertyInfo(Direction.OutputData, "Stream output","The string after processing with the Substitution cipher is converted to a stream. Default encoding is used.", null, true, false, QuickWatchFormat.Text, null)]
    67         public CryptoolStream OutputData
     66        public ICryptoolStream OutputData
    6867        {
    6968            get
    7069            {
    71                 if (outputString != null)
    72                 {
    73                     CryptoolStream cs = new CryptoolStream();
    74                     listCryptoolStreamsOut.Add(cs);
    75                     cs.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(outputString.ToCharArray()));
    76                     return cs;
    77                 }
    78                 else
     70                if (outputString == null)
    7971                {
    8072                    return null;
    8173                }
     74
     75                return new CStreamWriter(Encoding.Default.GetBytes(outputString));
    8276            }
    8377            set { }
     
    327321        public void Dispose()
    328322        {
    329             foreach (CryptoolStream stream in listCryptoolStreamsOut)
    330             {
    331                 stream.Close();
    332             }
    333             listCryptoolStreamsOut.Clear();
    334         }
     323            }
    335324
    336325        public bool HasChanges
  • trunk/CrypPlugins/TEA/TEA.cs

    r2334 r2529  
    3939
    4040        private TEASettings settings;
    41         private CryptoolStream inputStream;
    42         private CryptoolStream outputStream;
     41        private CStreamWriter outputStream;
    4342        private byte[] inputKey;
    4443        private bool stop = false;
    45         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4644
    4745        #endregion
     
    6058
    6159        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted.", "", true, false, QuickWatchFormat.Hex, null)]
    62         public CryptoolStream InputStream
    63         {
    64             get
    65             {
    66               if (inputStream != null)
    67               {
    68                 CryptoolStream cs = new CryptoolStream();
    69                 cs.OpenRead(inputStream.FileName);
    70                 listCryptoolStreamsOut.Add(cs);
    71                 return cs;
     60        public ICryptoolStream InputStream
     61        {
     62            get;
     63            set;
    7264              }
    73               else return null;
    74             }
    75             set
    76             {
    77               this.inputStream = value;
    78               if (value != null) listCryptoolStreamsOut.Add(value);
    79               OnPropertyChanged("InputStream");
    80             }
    81         }
    8265
    8366        [PropertyInfo(Direction.InputData, "Key", "Must be 16 bytes (128 bit).", "", true, false, QuickWatchFormat.Hex, null)]
     
    8871            {
    8972                this.inputKey = value;
    90                 OnPropertyChanged("InputKey");
    9173            }
    9274        }
    9375
    9476        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", "", true, false, QuickWatchFormat.Hex, null)]
    95         public CryptoolStream OutputStream
     77        public ICryptoolStream OutputStream
    9678        {
    9779            get
    9880            {
    99                 if (this.outputStream != null)
    100                 {
    101                     CryptoolStream cs = new CryptoolStream();
    102                     listCryptoolStreamsOut.Add(cs);
    103                     cs.OpenRead(this.outputStream.FileName);
    104                     return cs;
    105                 }
    106                 return null;
    107             }
     81                return outputStream;
     82                }
    10883            set
    10984            {
    110                 outputStream = value;
    111                 if (value != null) listCryptoolStreamsOut.Add(value);
    112                 OnPropertyChanged("OutputStream");
    11385            }
    11486        }
     
    12193                inputKey = null;
    12294                outputStream = null;
    123                 inputStream = null;
    124 
    125                 if (inputStream != null)
    126                 {
    127                     inputStream.Flush();
    128                     inputStream.Close();
    129                     inputStream = null;
    130                 }
     95
    13196                if (outputStream != null)
    13297                {
    13398                    outputStream.Flush();
    13499                    outputStream.Close();
     100                    outputStream.Dispose();
    135101                    outputStream = null;
    136102                }
    137                 foreach (CryptoolStream stream in listCryptoolStreamsOut)
    138                 {
    139                     stream.Close();
    140                 }
    141                 listCryptoolStreamsOut.Clear();
    142             }
     103                }
    143104            catch (Exception ex)
    144105            {
     
    150111        private void checkForInputStream()
    151112        {
    152             if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
     113            if (settings.Action == 0 && (InputStream == null || InputStream.Length == 0))
    153114            {
    154115                //create some input
    155116                String dummystring = "12345678";
    156                 this.inputStream = new CryptoolStream();
    157                 this.inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
     117                InputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring));
    158118                // write a warning to the outside world
    159119                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     120
     121                OnPropertyChanged("InputStream");
    160122            }
    161123        }
     
    173135                checkForInputStream();
    174136
    175                 if (inputStream == null || (inputStream != null && inputStream.Length == 0))
     137                if (InputStream == null)
    176138                {
    177139                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    179141                }
    180142
    181                 if (this.inputStream.CanSeek) this.inputStream.Position = 0;
    182 
    183                 outputStream = new CryptoolStream();
    184                 listCryptoolStreamsOut.Add(outputStream);
    185                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
    186 
    187                 long inputbytes = inputStream.Length;
    188                 GuiLogMessage("inputStream length [bytes]: " + inputStream.Length.ToString(), NotificationLevel.Debug);
    189                
     143                using (CStreamReader reader = InputStream.CreateReader())
     144                {
     145                    outputStream = new CStreamWriter();
     146
     147                    long inputbytes = reader.Length;
     148                    GuiLogMessage("inputStream length [bytes]: " + inputbytes.ToString(), NotificationLevel.Debug);
     149
    190150                int bytesRead = 0;
    191151                int blocksRead = 0;
     
    216176                        if (position < inputbytes)
    217177                        {
    218                             inputbuffer[position] = (byte)inputStream.ReadByte();
     178                                inputbuffer[position] = (byte)reader.ReadByte();
    219179                        }
    220180                        else // padding to do!
     
    234194                            {
    235195                                // no padding
    236                                 inputbuffer[position] = (byte)inputStream.ReadByte();
     196                                    inputbuffer[position] = (byte)reader.ReadByte();
    237197                                GuiLogMessage("Byte is: " + inputbuffer[position].ToString(), NotificationLevel.Info);
    238198                            }
     
    313273                        outputStream.Write(outputbuffer, 0, 4);
    314274                    }
    315                 } else if (action == 1) {
     275                    }
     276                    else if (action == 1)
     277                    {
    316278                    GuiLogMessage("Starting decryption [Keysize=128 Bits, Blocksize=64 Bits]", NotificationLevel.Info);
    317279                    for (int i = 0; i <= blocks-1; i++)
     
    361323                DateTime stopTime = DateTime.Now;
    362324                TimeSpan duration = stopTime - startTime;
    363                 //(outputStream as CryptoolStream).FinishWrite();
    364325
    365326                if (!stop)
     
    367328                    if (action == 0)
    368329                    {
    369                         GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
     330                            GuiLogMessage("Encryption complete! (in: " + inputbytes + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    370331                    }
    371332                    else
    372333                    {
    373                         GuiLogMessage("Decryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
    374                     }
    375                     GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Debug);
     334                            GuiLogMessage("Decryption complete! (in: " + inputbytes + " bytes, out: " + outbytes.ToString() + " bytes)", NotificationLevel.Info);
     335                    }
    376336                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    377337                    outputStream.Close();
     
    385345                }
    386346            }
    387             /*catch (CryptographicException cryptographicException)
    388             {
    389                 // TODO: For an unknown reason p_crypto_stream can not be closed after exception.
    390                 // Trying so makes p_crypto_stream throw the same exception again. So in Dispose
    391                 // the error messages will be doubled.
    392                 // As a workaround we set p_crypto_stream to null here.
    393                 p_crypto_stream = null;
    394                 //GuiLogMessage(cryptographicException.Message, NotificationLevel.Error);
    395             }*/
     347            }
    396348            catch (Exception exception)
    397349            {
     
    587539        public void PostExecution()
    588540        {
    589             Dispose();
    590541        }
    591542
    592543        public void PreExecution()
    593544        {
    594             Dispose();
    595545        }
    596546
  • trunk/CrypPlugins/TextInput/TextInput.cs

    r2255 r2529  
    1 /*
     1/*
    22   Copyright 2008 Thomas Schmid, University of Siegen
    33
     
    4040  {
    4141    private TextInputPresentation textInputPresentation;
    42     private List<CryptoolStream> listCryptoolStreams = new List<CryptoolStream>();
    4342
    4443    public TextInput()
     
    230229
    231230    [PropertyInfo(Direction.OutputData, "Stream", "The text input converted to memory stream.", "", true, false, QuickWatchFormat.None, null)]
    232     public CryptoolStream StreamOutput
     231    public ICryptoolStream StreamOutput
    233232    {
    234233      get
     
    237236        if (arr != null)
    238237        {
    239           CryptoolStream cryptoolStream = new CryptoolStream();
    240           listCryptoolStreams.Add(cryptoolStream);
    241 
    242           cryptoolStream.OpenRead(arr);
    243           // ShowProgress(100, 100);
    244           // GuiLogMessage("Got request for Stream. CryptoolStream created: " + cryptoolStream.FileName, NotificationLevel.Debug);
    245           return cryptoolStream;
     238            return new CStreamWriter(arr);
    246239        }
    247240        GuiLogMessage("Stream: No input provided. Returning null", NotificationLevel.Debug);
     
    344337    public void Dispose()
    345338    {
    346       foreach (CryptoolStream stream in listCryptoolStreams)
    347       {
    348         stream.Close();
    349       }
    350       listCryptoolStreams.Clear();
    351 
    352339      textInputPresentation.textBoxInputText.TextChanged -= textBoxInputText_TextChanged;
    353340    }
  • trunk/CrypPlugins/TextOutput/TextOutput.cs

    r2334 r2529  
    3131using Cryptool.PluginBase.Miscellaneous;
    3232using System.Runtime.Remoting.Contexts;
     33using System.Diagnostics;
    3334
    3435namespace TextOutput
     
    4142
    4243    #region Private variables
    43     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    4444    /// <summary>
    4545    /// This dic is used to store error messages while properties are set in PlayMode. The messages
     
    141141      switch (settings.CurrentDataType)
    142142      {
    143         case TextOutputSettings.DynamicDataTypes.CryptoolStream:
    144           return typeof(CryptoolStream);
     143        case TextOutputSettings.DynamicDataTypes.CStream:
     144          return typeof(ICryptoolStream);
    145145        case TextOutputSettings.DynamicDataTypes.String:
    146146          return typeof(string);
     
    164164      if (DicDynamicProperties.ContainsKey(name))
    165165      {
    166         switch (settings.CurrentDataType)
    167         {
    168           case TextOutputSettings.DynamicDataTypes.CryptoolStream:
    169             if ((CryptoolStream)DicDynamicProperties[name].Value != null)
    170             {
    171               CryptoolStream cryptoolStream = new CryptoolStream();
    172               listCryptoolStreamsOut.Add(cryptoolStream);
    173               cryptoolStream.OpenRead(((CryptoolStream)DicDynamicProperties[name].Value).FileName);
    174               return cryptoolStream;
     166            return DicDynamicProperties[name].Value;
    175167            }
    176168            else
     169        {
    177170              return null;
    178           case TextOutputSettings.DynamicDataTypes.String:
    179             return DicDynamicProperties[name].Value;
    180           case TextOutputSettings.DynamicDataTypes.ByteArray:
    181             return DicDynamicProperties[name].Value;
    182           case TextOutputSettings.DynamicDataTypes.Boolean:
    183             return DicDynamicProperties[name].Value;
    184           case TextOutputSettings.DynamicDataTypes.Integer:
    185             return DicDynamicProperties[name].Value;
    186           case TextOutputSettings.DynamicDataTypes.Double:
    187             return DicDynamicProperties[name].Value;
    188           case TextOutputSettings.DynamicDataTypes.Object:
    189             return DicDynamicProperties[name].Value;
    190           default:
    191             return null;
    192         }
    193       }
    194       return null;
    195     }
     171        }
     172      }
    196173
    197174    private void AddInput(string name, string toolTip)
     
    222199        else
    223200        {
     201           
     202
    224203            // check type explicitly, if connector type is set to anything else than object
    225             if (getCurrentType() != typeof(object) && !getCurrentType().Equals(value.GetType()))
     204            if (getCurrentType() != typeof(object) && !getCurrentType().IsAssignableFrom(value.GetType()))
    226205            {
    227206                GuiLogMessage(String.Format("Input data type does not match setting. Expected: {0}, Found: {1}", getCurrentType(), value.GetType()),
     
    241220                }
    242221            }
    243             else if (value is CryptoolStream)
    244             {
    245                 listCryptoolStreamsOut.Add((CryptoolStream)value);
    246                 CryptoolStream stream = value as CryptoolStream;
     222            else if (value is ICryptoolStream)
     223            {
     224                CStreamReader reader = ((ICryptoolStream)value).CreateReader();
    247225                // GuiLogMessage("Stream: Filling TextBoxes now...", NotificationLevel.Debug);
    248                 if (stream.Length > settings.MaxLength)
    249                     AddMessage("WARNING - Stream is too large (" + (stream.Length / 1024).ToString("0.00") + " kB), output will be truncated to " + (settings.MaxLength / 1024).ToString("0.00") + "kB", NotificationLevel.Warning);
    250                 byte[] byteValues = new byte[Math.Min(settings.MaxLength, stream.Length)];
     226                if (reader.Length > settings.MaxLength)
     227                    AddMessage("WARNING - Stream is too large (" + (reader.Length / 1024).ToString("0.00") + " kB), output will be truncated to " + (settings.MaxLength / 1024).ToString("0.00") + "kB", NotificationLevel.Warning);
     228                byte[] byteValues = new byte[Math.Min(settings.MaxLength, reader.Length)];
    251229                int bytesRead;
    252                 stream.Seek(0, SeekOrigin.Begin);
    253                 bytesRead = stream.Read(byteValues, 0, byteValues.Length);
     230                reader.Seek(0, SeekOrigin.Begin);
     231                bytesRead = reader.ReadFully(byteValues, 0, byteValues.Length);
    254232                fillValue = GetStringForSelectedEncoding(byteValues);
    255233            }
     
    468446    public void Dispose()
    469447    {
    470       foreach (CryptoolStream cryptoolStream in listCryptoolStreamsOut)
    471       {
    472         cryptoolStream.Close();
    473       }
    474       listCryptoolStreamsOut.Clear();
    475     }
     448      }
    476449
    477450    public void Stop()
     
    490463        }, null);
    491464      }
    492       foreach (DynamicProperty item in dicDynamicProperties.Values)
    493       {
    494         if (item.Value is CryptoolStream)
    495         {
    496           item.Value = null;
    497         }
    498       }
    499       Dispose();
    500     }
     465        }
    501466
    502467    public void PostExecution()
    503468    {
    504       Dispose();
    505469    }
    506470
  • trunk/CrypPlugins/TextOutput/TextOutputSettings.cs

    r2255 r2529  
    1 /*
     1/*
    22   Copyright 2008 Thomas Schmid, University of Siegen
    33
     
    3838
    3939    public enum EncodingTypes { Default = 0, Unicode = 1, UTF7 = 2, UTF8 = 3, UTF32 = 4, ASCII = 5, BigEndianUnicode = 6 };
    40     public enum DynamicDataTypes { CryptoolStream, String, ByteArray, Boolean, Integer , Double, Object};
     40    public enum DynamicDataTypes { CStream, String, ByteArray, Boolean, Integer , Double, Object};
    4141    public enum PresentationFormat { Text, Hex, Base64, Decimal }
    4242
     
    192192    }
    193193
    194     [TaskPane("Type", "Select DataType of plugin.", "", 4, false, ControlType.ComboBox, new string[] { "CryptoolStream", "string", "byte[]", "boolean", "int", "double", "object" })]
     194    [TaskPane("Type", "Select DataType of plugin.", "", 4, false, ControlType.ComboBox, new string[] { "CStream", "string", "byte[]", "boolean", "int", "double", "object" })]
    195195    public int DataType
    196196    {
  • trunk/CrypPlugins/Tiger/Tiger.cs

    r2334 r2529  
    136136    [PropertyInfo(Direction.InputData, "Input Data Stream", "Input data stream to be hashed", "",
    137137      false, false, QuickWatchFormat.Hex, null)]
    138     public CryptoolStream InputStream
    139     {
    140       get
    141       {
    142         CryptoolStream inputStream = new CryptoolStream();
    143         inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, inputdata);
    144         return inputStream;
     138    public ICryptoolStream InputStream
     139    {
     140      get
     141      {
     142          if (inputdata == null)
     143          {
     144              return null;
     145      }
     146          else
     147          {
     148              return new CStreamWriter(inputdata);
     149          }
    145150      }
    146151      set
    147152      {
    148         if (null == value)
     153        if (value != null)
    149154        {
    150           inputdata = new byte[0];
    151           return;
     155            using (CStreamReader reader = value.CreateReader())
     156            {
     157                inputdata = reader.ReadFully();
     158                GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
    152159        }
    153         //if (inputCanal != dataCanal.none && inputCanal != dataCanal.streamCanal)
    154         //  GuiLogMessage("Duplicate input data not allowed!", NotificationLevel.Error);
    155         //inputCanal = dataCanal.streamCanal;
    156 
    157         long len = value.Length;
    158         inputdata = new byte[len];
    159 
    160         for (long i = 0; i < len; i++)
    161           inputdata[i] = (byte)value.ReadByte();
    162160
    163161        NotifyUpdateInput();
    164         GuiLogMessage("InputStream changed.", NotificationLevel.Debug);
    165       }
     162      }
     163    }
    166164    }
    167165
     
    180178      set
    181179      {
    182         //if (inputCanal != dataCanal.none && inputCanal != dataCanal.byteCanal)
    183         //  GuiLogMessage("Duplicate Data data not allowed!", NotificationLevel.Error);
    184         //inputCanal = dataCanal.byteCanal;
    185         if (null == value)
     180          if (inputdata != value)
    186181        {
    187           inputdata = new byte[0];
    188           return;
    189         }
    190         long len = value.Length;
    191         inputdata = new byte[len];
    192 
    193         for (long i = 0; i < len; i++)
    194           inputdata[i] = value[i];
    195 
    196         NotifyUpdateInput();
     182              inputdata = (value == null) ? new byte[0] : null;
    197183        GuiLogMessage("InputData changed.", NotificationLevel.Debug);
    198       }
     184              NotifyUpdateInput();
     185      }
     186    }
    199187    }
    200188    #endregion
     
    203191
    204192    // Output
    205     private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    206193    private byte[] outputData = { };
    207194
     
    222209    [PropertyInfo(Direction.OutputData, "Hashed Stream", "Output stream of the hashed value", "",
    223210      true, false, QuickWatchFormat.Hex, null)]
    224     public CryptoolStream HashOutputStream
    225     {
    226       get
    227       {
    228         CryptoolStream outputDataStream = null;
    229         if (outputData != null)
    230         {
    231           outputDataStream = new CryptoolStream();
    232           outputDataStream.OpenRead(this.GetPluginInfoAttribute().Caption, outputData);
    233           listCryptoolStreamsOut.Add(outputDataStream);
     211    public ICryptoolStream HashOutputStream
     212    {
     213      get
     214      {
     215          return new CStreamWriter(outputData);
    234216        }
    235         GuiLogMessage("Got HashOutputStream.", NotificationLevel.Debug);
    236         return outputDataStream;
    237       }
    238217      //set
    239218      //{
     
    348327    public void Dispose()
    349328    {
    350       foreach (CryptoolStream stream in listCryptoolStreamsOut)
    351       {
    352         stream.Close();
    353       }
    354       listCryptoolStreamsOut.Clear();
    355     }
     329      }
    356330
    357331    #endregion
  • trunk/CrypPlugins/TripleDES/TripleDES.cs

    r2334 r2529  
    2323        #region Private variables
    2424        private TripleDESSettings settings;
    25         private CryptoolStream inputStream;
    26         private CryptoolStream outputStream;
     25        private ICryptoolStream inputStream;
     26        private CStreamWriter outputStreamWriter;
    2727        private byte[] inputKey;
    2828        private byte[] inputIV;
    2929        private CryptoStream p_crypto_stream;
    3030        private bool stop = false;
    31         private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
    3231        #endregion
    3332
     
    5049
    5150        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", null, true, false,QuickWatchFormat.Hex, null)]
    52         public CryptoolStream InputStream
     51        public ICryptoolStream InputStream
    5352        {
    5453            get
    5554            {
    56                 if (inputStream != null)
    57                 {
    58                     CryptoolStream cs = new CryptoolStream();
    59                     cs.OpenRead(inputStream.FileName);
    60                     listCryptoolStreamsOut.Add(cs);
    61                     return cs;
    62                 }
    63                 else return null;
    64             }
     55                return inputStream;
     56                }
    6557            set
    6658            {
    6759                this.inputStream = value;
    68                 if (value != null) listCryptoolStreamsOut.Add(value);
    69                 OnPropertyChanged("InputStream");
    7060            }
    7161        }
     
    9585
    9686        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", null, true, false,QuickWatchFormat.Hex, null)]
    97         public CryptoolStream OutputStream
     87        public ICryptoolStream OutputStream
    9888        {
    9989            get
    10090            {
    101                 if (this.outputStream != null)
    102                 {
    103                     CryptoolStream cs = new CryptoolStream();
    104                     listCryptoolStreamsOut.Add(cs);
    105                     cs.OpenRead(this.outputStream.FileName);
    106                     return cs;
    107                 }
    108                 return null;
    109             }
     91                return outputStreamWriter;
     92                }
    11093            set
    11194            {
    112                 outputStream = value;
    113                 if (value != null) listCryptoolStreamsOut.Add(value);
    114                 OnPropertyChanged("OutputStream");
     95                //wander 20100520: unnecessary, propagated by Execute()
     96                //OnPropertyChanged("OutputStream");
    11597            }
    11698        }
     
    155137        private void checkForInputStream()
    156138        {
    157             if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
     139            if (settings.Action == 0 && (inputStream == null || inputStream.Length == 0))
    158140            {
    159141                //create some input
    160142                String dummystring = "Dummy string - no input provided - \"Hello TripleDES World\" - dummy string - no input provided!";
    161                 this.inputStream = new CryptoolStream();
    162                 this.inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
     143                this.inputStream = new CStreamWriter(Encoding.Default.GetBytes(dummystring));
    163144                // write a warning to the ouside word
    164145                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
     
    177158            {
    178159                checkForInputStream();
    179                 if (inputStream == null || (inputStream != null && inputStream.Length == 0))
     160                if (inputStream == null || inputStream.Length == 0)
    180161                {
    181162                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
     
    183164                }
    184165
    185                 if (this.inputStream.CanSeek) this.inputStream.Position = 0;
     166                using (CStreamReader reader = inputStream.CreateReader())
     167                {
    186168                SymmetricAlgorithm p_alg = new TripleDESCryptoServiceProvider();
    187169
     
    199181                }
    200182
    201                 outputStream = new CryptoolStream();
    202                 listCryptoolStreamsOut.Add(outputStream);
    203                 outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
    204                 p_crypto_stream = new CryptoStream((Stream)inputStream, p_encryptor, CryptoStreamMode.Read);
     183                    outputStreamWriter = new CStreamWriter();
     184                    p_crypto_stream = new CryptoStream(reader, p_encryptor, CryptoStreamMode.Read);
    205185                byte[] buffer = new byte[p_alg.BlockSize / 8];
    206186                int bytesRead;
     
    210190                while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
    211191                {
    212                     outputStream.Write(buffer, 0, bytesRead);
    213 
    214                     if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
     192                        outputStreamWriter.Write(buffer, 0, bytesRead);
     193
     194                        if ((int)(reader.Position * 100 / reader.Length) > position)
    215195                    {
    216                         position = (int)(inputStream.Position * 100 / inputStream.Length);
    217                         ProgressChanged(inputStream.Position, inputStream.Length);
     196                            position = (int)(reader.Position * 100 / reader.Length);
     197                            ProgressChanged(reader.Position, reader.Length);
    218198                    }
    219199                }
    220200                p_crypto_stream.Flush();
    221201                // p_crypto_stream.Close();
    222                 outputStream.Close();
     202                    outputStreamWriter.Close();
    223203                DateTime stopTime = DateTime.Now;
    224204                TimeSpan duration = stopTime - startTime;
    225                 // (outputStream as CryptoolStream).FinishWrite();
    226205                if (!stop)
    227206                {
    228                     GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
    229                     GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
     207                        GuiLogMessage("Encryption complete! (in: " + reader.Length.ToString() + " bytes, out: " + outputStreamWriter.Length.ToString() + " bytes)", NotificationLevel.Info);
    230208                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
    231209                    OnPropertyChanged("OutputStream");
     
    235213                    GuiLogMessage("Aborted!", NotificationLevel.Info);
    236214                }
     215            }
    237216            }
    238217            catch (CryptographicException cryptographicException)