public void Dispose()
{
try
{
stop = false;
counter = 0;
lengthOfInputByte = 0;
lengthOfOutputByte = 0;
inputByteKey = null;
iV = null;
outputByte = null;
crc32 = null;
key = null;
if (internalInputByteList != null)
{
internalInputByteList.Clear();
}
internalInputByteList = null;
inputStream = null;
//if (outputByteList != null) { outputByteList.Clear(); }
//outputByteList = null;
outputStreamWriter = null;
if (internalInputByteList != null)
{
internalInputByteList.Clear();
}
//internalInputByteList = null;
}
catch (Exception exc)
{
GuiLogMessage(exc.Message.ToString(), NotificationLevel.Error);
}
this.stop = false;
}
public void Dispose()
{
if (inputData != null)
{
inputData = null;
}
}
public void SHATestMethod()
{
var pluginInstance = TestHelpers.GetPluginInstance("SHA");
var scenario1 = new PluginTestScenario(pluginInstance, new[] { "InputData", ".SHAFunction" }, new[] { "OutputDataStream" });
var scenario2 = new PluginTestScenario(pluginInstance, new[] { "InputData", ".SHAFunction" }, new[] { "OutputData" });
object[] output;
foreach (TestVector vector in testvectors)
{
output = scenario1.GetOutputs(new object[] { vector.input.ToStream(), vector.mode });
Assert.AreEqual(vector.output.ToUpper(), output[0].ToHex(), "Unexpected value in test #" + vector.n + ".");
output = scenario2.GetOutputs(new object[] { vector.input.ToStream(), vector.mode });
Assert.AreEqual(vector.output.ToUpper(), output[0].ToHex(), "Unexpected value in test #" + vector.n + ".");
}
foreach (TestVector vector in testvectors_loop)
{
ICryptoolStream input = vector.input.ToStream();
for (int i = 0; i < 100000; i++)
{
input = (ICryptoolStream)scenario1.GetOutputs(new object[] { input, vector.mode })[0];
}
Assert.AreEqual(vector.output.ToUpper(), input.ToHex(), "Unexpected value in iteration test #" + vector.n + ".");
}
}
public void Dispose()
{
InputIV = null;
InputKey = null;
InputStream = null;
OutputStream = null;
}
public void Dispose()
{
stop = false;
inputKey = null;
inputData = null;
outputStreamWriter = null;
}
public void Dispose()
{
try
{
stop = false;
inputKey = null;
inputIV = null;
inputStream = null;
outputStream = null;
if (p_crypto_stream_dec != null)
{
p_crypto_stream_dec.Flush();
p_crypto_stream_dec.Close();
p_crypto_stream_dec = null;
}
if (p_crypto_stream_enc != null)
{
p_crypto_stream_enc.Flush();
p_crypto_stream_enc.Close();
p_crypto_stream_enc = null;
}
}
catch (Exception exception)
{
GuiLogMessage(exception.Message, NotificationLevel.Error);
}
this.stop = false;
}
public static byte[] ToByteArray(this ICryptoolStream stream)
{
if (stream == null)
{
return(new byte[0]);
}
return(stream.CreateReader().ToByteArray());
}
public static string ToHex(this ICryptoolStream stream)
{
if (stream == null)
{
return("");
}
return(stream.ToByteArray().ToHex());
}
private byte[] ToByteArray(ICryptoolStream icstr)
{
CStreamReader stream = icstr.CreateReader();
stream.WaitEof();
byte[] buffer = new byte[stream.Length];
stream.Seek(0, System.IO.SeekOrigin.Begin);
stream.ReadFully(buffer);
return(buffer);
}
private string Stream2Base64(ICryptoolStream value)
{
using (CStreamReader reader = value.CreateReader())
{
reader.WaitEof();
byte[] byteValues = new byte[reader.Length];
reader.Read(byteValues, 0, (int)reader.Length);
return(Convert.ToBase64String(byteValues));
}
}
public void TestEmpty()
{
ICryptoolStream empty = CStreamWriter.Empty;
CStreamReader reader = empty.CreateReader();
byte[] buf = new byte[1024];
int read = reader.ReadFully(buf);
Assert.AreEqual(0, read);
}
/// <summary>
/// Called once when workflow execution starts.
/// </summary>
public void PreExecution()
{
inputImage = null;
orgImg = null;
step1Img = null;
step2Img = null;
step4Img = null;
step6Bmp = null;
outputHash = null;
isRunning = true;
}
/// <summary>
/// Assigns a data source and initializes the algorithm, putting it into "initialized" state
/// </summary>
/// <param name="cStream">Data source</param>
public void Initialize(ICryptoolStream cStream)
{
DataStream = cStream.CreateReader();
SetUninitializedState();
PerformInitializationStep();
IsInitialized = true;
OnStatusChanged();
}
private string Stream2Hex(ICryptoolStream value)
{
using (CStreamReader reader = value.CreateReader())
{
int byteValue;
StringBuilder sb = new StringBuilder();
while ((byteValue = reader.ReadByte()) != -1)
{
sb.Append(byteValue.ToString("x2"));
}
return(sb.ToString());
}
}
public static byte[] StreamToByteArray(ICryptoolStream stream)
{
byte[] buf = new byte[stream.Length];
CStreamReader reader = stream.CreateReader();
reader.WaitEof();
reader.Seek(0, System.IO.SeekOrigin.Begin);
reader.ReadFully(buf);
reader.Close();
return(buf);
}
private string Stream2Text(ICryptoolStream value)
{
using (CStreamReader reader = value.CreateReader())
{
int byteValue;
StringBuilder sb = new StringBuilder();
while ((byteValue = reader.ReadByte()) != -1)
{
// FIXME: UTF-8 characters may consist of more than a single byte
sb.Append(System.Convert.ToChar(byteValue));
}
return(sb.ToString());
}
}
public void PreExecution()
{
_data = null;
_stream = null;
_presentation.Dispatcher.Invoke(DispatcherPriority.Background, (SendOrPostCallback) delegate
{
try
{
_presentation.Picture.Source = null;
}
catch (Exception ex)
{
GuiLogMessage("Could not clear picture in PreExecute: " + ex.Message, NotificationLevel.Error);
}
}, null);
}
// convert stream to ulong
private ulong stream2ulong(ICryptoolStream s)
{
byte[] tmpbuf = s.ToByteArray();
Array.Reverse(tmpbuf);
byte[] buf = new byte[8];
for (int i = 0; i < 8; i++)
{
buf[i] = 0;
}
for (int i = 0; i < tmpbuf.Length; i++)
{
buf[i] = tmpbuf[i];
}
return(BitConverter.ToUInt64(buf, 0));
}
public void Execute()
{
if (amountOfNumbers <= 0)
{
GuiLogMessage("Negative amount of numbers cant be generated", NotificationLevel.Warning);
ProgressChanged(1, 1);
return;
}
if (hasSeed)
{
setSeed(seed);
}
ProgressChanged(0, 1);
CStreamWriter writer = new CStreamWriter();
data = writer;
uint current;
byte[] nextData;
outputNumbers = new BigInteger[amountOfNumbers];
for (int i = 0; i < amountOfNumbers; i++)
{
// nothing to say here, it is simple writing the necessary amount of uints onto the stream
current = getNextUInt();
outputNumbers[i] = current;
nextData = BitConverter.GetBytes(current);
if (littleEndian)
{
Array.Reverse(nextData);
}
writer.Write(nextData);
ProgressChanged(i, amountOfNumbers);
}
writer.Close();
OnPropertyChanged("OutputData");
OnPropertyChanged("OutputNumbers");
GuiLogMessage("Generation finished", NotificationLevel.Debug);
ProgressChanged(1, 1);
}
private byte[] ConvertStreamToByteArray(ICryptoolStream stream)
{
CStreamReader reader = stream.CreateReader();
reader.WaitEof(); // does not support chunked streaming
if (reader.Length > settings.MaxLength)
{
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);
}
byte[] byteArray = new byte[Math.Min(settings.MaxLength, reader.Length)];
reader.Seek(0, SeekOrigin.Begin);
reader.ReadFully(byteArray, 0, byteArray.Length);
reader.Close();
return(byteArray);
}
public void SetContent(ICryptoolStream stream)
{
Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
{
try
{
using (CStreamReader reader = stream.CreateReader())
{
FlowDocument flowDocumentNew = (FlowDocument)XamlReader.Load(reader);
documentReader.Document = flowDocumentNew;
}
}
catch (Exception)
{
documentReader.Document = null;
}
}, documentReader);
}
private string returnStreamContent(ICryptoolStream stream)
{
string res = "";
if (stream == null)
{
return(null);
}
using (CStreamReader reader = stream.CreateReader())
{
res = Encoding.Default.GetString(reader.ReadFully());
if (res.Length == 0)
{
return(null);
}
}
return(res);
}
public void Dispose()
{
try
{
stop = false;
inputKey = null;
inputIV = null;
inputStream = null;
outputStreamWriter = null;
if (p_crypto_stream != null)
{
p_crypto_stream.Flush();
p_crypto_stream.Clear();
p_crypto_stream = null;
}
}
catch (Exception ex)
{
GuiLogMessage(ex.Message, NotificationLevel.Error);
}
this.stop = false;
}
public void PostExecution()
{
inputData = null;
}
public void Decrypt()
{
if (this.inputStream != null)
{
// Decrypt Stream
try
{
SymmetricAlgorithm p_alg = new PresentManaged();
ConfigureAlg(p_alg, true);
ICryptoolStream inputdata = InputStream;
CStreamReader reader = inputdata.CreateReader();
ICryptoTransform p_decryptor = p_alg.CreateDecryptor();
outputStream = new CStreamWriter();
p_crypto_stream_dec = new CryptoStream((Stream)reader, p_decryptor, CryptoStreamMode.Read);
byte[] buffer = new byte[p_alg.BlockSize / 8];
int bytesRead;
int position = 0;
DateTime startTime = DateTime.Now;
while ((bytesRead = p_crypto_stream_dec.Read(buffer, 0, buffer.Length)) > 0 && !stop)
{
outputStream.Write(buffer, 0, bytesRead);
if ((int)(reader.Position * 100 / inputStream.Length) > position)
{
position = (int)(reader.Position * 100 / inputStream.Length);
Progress(reader.Position, inputStream.Length);
}
}
p_crypto_stream_dec.Flush();
p_crypto_stream_dec.Close();
DateTime stopTime = DateTime.Now;
TimeSpan duration = stopTime - startTime;
outputStream.Close();
if (settings.Action == 1)
{
outputStream = BlockCipherHelper.StripPadding(outputStream, settings.padmap[settings.Padding], p_alg.BlockSize / 8) as CStreamWriter;
}
if (!stop)
{
GuiLogMessage("Decryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
OnPropertyChanged("OutputStream");
}
else
{
GuiLogMessage("Aborted!", NotificationLevel.Info);
}
}
catch (CryptographicException cryptographicException)
{
// TODO: For an unknown reason p_crypto_stream can not be closed after exception.
// Trying so makes p_crypto_stream throw the same exception again. So in Dispose
// the error messages will be doubled.
// As a workaround we set p_crypto_stream to null here.
p_crypto_stream_dec = null;
GuiLogMessage(cryptographicException.Message, NotificationLevel.Error);
}
catch (Exception exception)
{
GuiLogMessage(exception.Message, NotificationLevel.Error);
}
finally
{
Progress(1, 1);
}
}
}
private void process(int action)
{
//Encrypt/Decrypt Stream
try
{
if (inputStream == null || inputStream.Length == 0)
{
GuiLogMessage("No input data, aborting now", NotificationLevel.Error);
return;
}
ICryptoTransform p_encryptor;
SymmetricAlgorithm p_alg = new RC2CryptoServiceProvider();
ConfigureAlg(p_alg);
outputStreamWriter = new CStreamWriter();
ICryptoolStream inputdata = InputStream;
if (action == 0)
{
inputdata = BlockCipherHelper.AppendPadding(InputStream, settings.padmap[settings.Padding], p_alg.BlockSize / 8);
}
CStreamReader reader = inputdata.CreateReader();
GuiLogMessage("Starting " + ((settings.Action == 0)?"encryption":"decryption") + " [Keysize=" + p_alg.KeySize.ToString() + " Bits, Blocksize=" + p_alg.BlockSize.ToString() + " Bits]", NotificationLevel.Info);
DateTime startTime = DateTime.Now;
// special handling of OFB mode, as it's not available for RC2 in .Net
if (settings.Mode == 3) // OFB - bei OFB ist encrypt = decrypt, daher keine Fallunterscheidung
{
p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV);
byte[] IV = new byte[p_alg.IV.Length];
Array.Copy(p_alg.IV, IV, p_alg.IV.Length);
byte[] tmpInput = BlockCipherHelper.StreamToByteArray(inputdata);
byte[] outputData = new byte[tmpInput.Length];
for (int pos = 0; pos <= tmpInput.Length - p_encryptor.InputBlockSize;)
{
int l = p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos);
for (int i = 0; i < l; i++)
{
IV[i] = outputData[pos + i];
outputData[pos + i] ^= tmpInput[pos + i];
}
pos += l;
}
outputStreamWriter.Write(outputData);
}
else
{
p_encryptor = (action == 0) ? p_alg.CreateEncryptor() : p_alg.CreateDecryptor();
p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read);
byte[] buffer = new byte[p_alg.BlockSize / 8];
int bytesRead;
while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
{
outputStreamWriter.Write(buffer, 0, bytesRead);
}
p_crypto_stream.Flush();
}
outputStreamWriter.Close();
DateTime stopTime = DateTime.Now;
TimeSpan duration = stopTime - startTime;
if (action == 1)
{
outputStreamWriter = BlockCipherHelper.StripPadding(outputStreamWriter, settings.padmap[settings.Padding], p_alg.BlockSize / 8) as CStreamWriter;
}
if (!stop)
{
GuiLogMessage(((settings.Action == 0) ? "Encryption" : "Decryption") + " complete! (in: " + InputStream.Length + " bytes, out: " + outputStreamWriter.Length + " bytes)", NotificationLevel.Info);
GuiLogMessage("Time used: " + duration, NotificationLevel.Debug);
OnPropertyChanged("OutputStream");
}
else
{
GuiLogMessage("Aborted!", NotificationLevel.Info);
}
}
catch (CryptographicException cryptographicException)
{
// TODO: For an unknown reason p_crypto_stream can not be closed after exception.
// Trying so makes p_crypto_stream throw the same exception again. So in Dispose
// the error messages will be doubled.
// As a workaround we set p_crypto_stream to null here.
p_crypto_stream = null;
GuiLogMessage(cryptographicException.Message, NotificationLevel.Error);
}
catch (Exception exception)
{
GuiLogMessage(exception.Message, NotificationLevel.Error);
}
finally
{
ProgressChanged(1, 1);
}
}
public void PreExecution()
{
inputData = null;
}
/// <summary>
/// HOWTO: Enter the algorithm you'd like to implement in this method.
/// </summary>
public void Execute()
{
int matrixSize;
switch (settings.MatrixSize)
{
case 0:
matrixSize = 5;
break;
case 1:
matrixSize = 6;
break;
default:
matrixSize = 5;
break;
}
// HOWTO: Use this to show the progress of a plugin algorithm execution in the editor.
ProgressChanged(0, 1);
// HOWTO: After you have changed an output property, make sure you announce the name of the changed property to the CT2 core.
//OnPropertyChanged("Difference");
// HOWTO: You can pass error, warning, info or debug messages to the CT2 main window.
GuiLogMessage("Text Corpus File: " + settings.TextCorpusFile, NotificationLevel.Info);
if ((settings.Alphabet.Contains(settings.Separator)) && (settings.Alphabet.Contains(settings.SeparatorReplacement)) &&
(settings.Alphabet.Contains(settings.ReplacementChar)))
{
if (!ContainsDuplicates(settings.Alphabet))
{
if (settings.TextCorpusFile != null && settings.TextCorpusFile.EndsWith(".txt"))
{
if (((matrixSize == 5) && (settings.Alphabet.Length == 25)) ||
((matrixSize == 6) && (settings.Alphabet.Length == 36)))
{
unformattedTextByte = System.IO.File.ReadAllBytes(settings.TextCorpusFile);
unformattedText = Encoding.Default.GetString(unformattedTextByte);
GuiLogMessage(settings.Alphabet, NotificationLevel.Info);
SortAlphabet(settings.Alphabet);
GuiLogMessage("sortedAlphabet: " + sortedAlphabet, NotificationLevel.Info);
GuiLogMessage("ToUpper: " + Convert.ToString(settings.CorpusToUpper), NotificationLevel.Info);
FormatText();
GuiLogMessage("formatted text: " + formattedText, NotificationLevel.Info);
CalcLogStat();
// Write Alphabet Length, sortedAlphabet and logStat (double array) in logStatByte (byte array)
logStatByte = new byte[(8 * logStat.Length) + 1 + sortedAlphabet.Length];
byte[] doubleValue = new byte[8];
int index = 0;
logStatByte[index] = (byte)sortedAlphabet.Length;
index++;
for (int i = 0; i < sortedAlphabet.Length; i++)
{
logStatByte[index] = Convert.ToByte(sortedAlphabet[i]);
index++;
}
for (int i = 0; i < (int)Math.Pow(matrixSize, 2); i++)
{
for (int j = 0; j < (int)Math.Pow(matrixSize, 2); j++)
{
doubleValue = BitConverter.GetBytes(logStat[i, j]);
for (int k = 0; k < 8; k++)
{
logStatByte[index] = doubleValue[k];
index++;
}
}
}
csBigraphStatistic = new CStreamWriter(logStatByte);
OnPropertyChanged("OutputStream");
GuiLogMessage("CalcLogStat completed: ", NotificationLevel.Info);
}
else
{
System.Windows.MessageBox.Show("Wrong Alphabet Length!\nAlphabet must contain " + Convert.ToString(Math.Pow(matrixSize, 2)) + " characters.");
}
}
else if (settings.TextCorpusFile == null)
{
System.Windows.MessageBox.Show("For calculating the bigraph statistic a text corpus file is needed!");
}
else
{
System.Windows.MessageBox.Show("Text Corpus File has to be a .txt file!");
settings.TextCorpusFile = null;
}
}
else
{
System.Windows.MessageBox.Show("Alphabet contains duplicate characters!");
}
}
else
{
System.Windows.MessageBox.Show("Alphabet must contain Separator, Separator Replacement and Replacement Character!");
}
ProgressChanged(1, 1);
}
private void Crypt()
{
try
{
ICryptoTransform p_encryptor;
SymmetricAlgorithm p_alg = TwofishManaged.Create();
ConfigureAlg(p_alg);
outputStreamWriter = new CStreamWriter();
ICryptoolStream inputdata = InputStream;
if (settings.Action == 0)
{
inputdata = BlockCipherHelper.AppendPadding(InputStream, settings.padmap[settings.Padding], p_alg.BlockSize / 8);
}
CStreamReader reader = inputdata.CreateReader();
byte[] tmpInput = BlockCipherHelper.StreamToByteArray(inputdata);
byte[] outputData = new byte[tmpInput.Length];
byte[] IV = new byte[p_alg.IV.Length];
Array.Copy(p_alg.IV, IV, p_alg.IV.Length);
int bs = p_alg.BlockSize >> 3;
if (settings.Mode == 0) // ECB
{
p_encryptor = (settings.Action == 0) ? p_alg.CreateEncryptor(p_alg.Key, p_alg.IV) : p_alg.CreateDecryptor(p_alg.Key, p_alg.IV);
for (int pos = 0; pos < tmpInput.Length; pos += bs)
{
p_encryptor.TransformBlock(tmpInput, pos, bs, outputData, pos);
}
}
else if (settings.Mode == 1) // CBC
{
if (settings.Action == 0)
{
p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV);
for (int pos = 0; pos < tmpInput.Length; pos += bs)
{
for (int i = 0; i < bs; i++)
{
tmpInput[pos + i] ^= IV[i];
}
p_encryptor.TransformBlock(tmpInput, pos, bs, outputData, pos);
for (int i = 0; i < bs; i++)
{
IV[i] = outputData[pos + i];
}
}
}
else
{
p_encryptor = p_alg.CreateDecryptor(p_alg.Key, p_alg.IV);
for (int pos = 0; pos < tmpInput.Length; pos += bs)
{
p_encryptor.TransformBlock(tmpInput, pos, bs, outputData, pos);
for (int i = 0; i < bs; i++)
{
outputData[pos + i] ^= IV[i];
IV[i] = tmpInput[pos + i];
}
}
}
}
else if (settings.Mode == 2) // CFB
{
p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV);
if (settings.Action == 0)
{
for (int pos = 0; pos < tmpInput.Length; pos += bs)
{
p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos);
for (int i = 0; i < bs; i++)
{
outputData[pos + i] ^= tmpInput[pos + i];
IV[i] = outputData[pos + i];
}
}
}
else
{
for (int pos = 0; pos < tmpInput.Length; pos += bs)
{
p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos);
for (int i = 0; i < bs; i++)
{
IV[i] = tmpInput[pos + i];
outputData[pos + i] ^= tmpInput[pos + i];
}
}
}
}
else if (settings.Mode == 3) // OFB
{
p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV);
for (int pos = 0; pos < tmpInput.Length; pos += bs)
{
p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos);
for (int i = 0; i < bs; i++)
{
IV[i] = outputData[pos + i];
outputData[pos + i] ^= tmpInput[pos + i];
}
}
}
outputStreamWriter.Write(outputData);
//if( p_encryptor!=null ) p_encryptor.Dispose();
outputStreamWriter.Close();
if (settings.Action == 1)
{
outputStreamWriter = BlockCipherHelper.StripPadding(outputStreamWriter, settings.padmap[settings.Padding], p_alg.BlockSize / 8) as CStreamWriter;
}
OnPropertyChanged("OutputStream");
}
catch (CryptographicException cryptographicException)
{
// TODO: For an unknown reason p_crypto_stream can not be closed after exception.
// Trying so makes p_crypto_stream throw the same exception again. So in Dispose
// the error messages will be doubled.
// As a workaround we set p_crypto_stream to null here.
p_crypto_stream = null;
GuiLogMessage(cryptographicException.Message, NotificationLevel.Error);
}
catch (Exception exception)
{
GuiLogMessage(exception.Message, NotificationLevel.Error);
}
}
private void process(int action)
{
//Encrypt/Decrypt Stream
try
{
if (InputStream == null || InputStream.Length == 0)
{
GuiLogMessage("No input data, aborting now", NotificationLevel.Error);
return;
}
ICryptoTransform p_encryptor;
SymmetricAlgorithm p_alg = null;
if (settings.TripleDES)
{
p_alg = new TripleDESCryptoServiceProvider();
}
else
{
p_alg = new DESCryptoServiceProvider();
}
ConfigureAlg(p_alg);
outputStreamWriter = new CStreamWriter();
ICryptoolStream inputdata = InputStream;
// append 1-0 padding (special handling, as it's not present in System.Security.Cryptography.PaddingMode)
if (action == 0)
{
inputdata = BlockCipherHelper.AppendPadding(InputStream, settings.padmap[settings.Padding], p_alg.BlockSize / 8);
}
CStreamReader reader = inputdata.CreateReader();
//GuiLogMessage("Starting encryption [Keysize=" + p_alg.KeySize.ToString() + " Bits, Blocksize=" + p_alg.BlockSize.ToString() + " Bits]", NotificationLevel.Info);
DateTime startTime = DateTime.Now;
// special handling of OFB mode, as it's not available for DES in .Net
if (settings.Mode == 3) // OFB - bei OFB ist encrypt = decrypt, daher keine Fallunterscheidung
{
try
{
p_encryptor = p_alg.CreateEncryptor(p_alg.Key, p_alg.IV);
}
catch
{
//dirty hack to allow weak keys:
MethodInfo mi = p_alg.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
object[] Par = { p_alg.Key, p_alg.Mode, p_alg.IV, p_alg.FeedbackSize, 0 };
p_encryptor = mi.Invoke(p_alg, Par) as ICryptoTransform;
}
byte[] IV = new byte[p_alg.IV.Length];
Array.Copy(p_alg.IV, IV, p_alg.IV.Length);
byte[] tmpInput = BlockCipherHelper.StreamToByteArray(inputdata);
byte[] outputData = new byte[tmpInput.Length];
for (int pos = 0; pos <= tmpInput.Length - p_encryptor.InputBlockSize;)
{
int l = p_encryptor.TransformBlock(IV, 0, p_encryptor.InputBlockSize, outputData, pos);
for (int i = 0; i < l; i++)
{
IV[i] = outputData[pos + i];
outputData[pos + i] ^= tmpInput[pos + i];
}
pos += l;
}
outputStreamWriter.Write(outputData);
}
else
{
try
{
p_encryptor = (action == 0) ? p_alg.CreateEncryptor() : p_alg.CreateDecryptor();
}
catch
{
//dirty hack to allow weak keys:
MethodInfo mi = (action == 0) ? p_alg.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance)
: p_alg.GetType().GetMethod("_NewDecryptor", BindingFlags.NonPublic | BindingFlags.Instance);;
object[] par = { p_alg.Key, p_alg.Mode, p_alg.IV, p_alg.FeedbackSize, 0 };
p_encryptor = mi.Invoke(p_alg, par) as ICryptoTransform;
}
p_crypto_stream = new CryptoStream((Stream)reader, p_encryptor, CryptoStreamMode.Read);
byte[] buffer = new byte[p_alg.BlockSize / 8];
int bytesRead;
while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
{
//// remove 1-0 padding (special handling, as it's not present in System.Security.Cryptography.PaddingMode)
//if (action == 1 && settings.Padding == 5 && reader.Position == reader.Length)
// bytesRead = BlockCipherHelper.StripPadding(buffer, bytesRead, BlockCipherHelper.PaddingType.OneZeros, buffer.Length);
outputStreamWriter.Write(buffer, 0, bytesRead);
}
p_crypto_stream.Flush();
}
outputStreamWriter.Close();
//DateTime stopTime = DateTime.Now;
//TimeSpan duration = stopTime - startTime;
if (action == 1)
{
outputStreamWriter = BlockCipherHelper.StripPadding(outputStreamWriter, settings.padmap[settings.Padding], p_alg.BlockSize / 8) as CStreamWriter;
}
if (!stop)
{
//GuiLogMessage("Encryption complete! (in: " + reader.Length.ToString() + " bytes, out: " + outputStreamWriter.Length.ToString() + " bytes)", NotificationLevel.Info);
//GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
OnPropertyChanged("OutputStream");
}
else
{
GuiLogMessage("Aborted!", NotificationLevel.Info);
}
}
catch (CryptographicException cryptographicException)
{
p_crypto_stream = null;
string msg = cryptographicException.Message;
// Workaround for misleading padding error message
if (msg.StartsWith("Ungültige Daten"))
{
msg = "Das Padding ist ungültig und kann nicht entfernt werden.";
}
GuiLogMessage(msg, NotificationLevel.Error);
}
catch (Exception exception)
{
GuiLogMessage(exception.Message, NotificationLevel.Error);
}
finally
{
ProgressChanged(1, 1);
}
}