public void TestSeek()
{
CStreamWriter writer = new CStreamWriter();
writer.Write(LongData);
writer.Close();
CStreamReader reader = writer.CreateReader();
byte[] buf = new byte[1024];
{ // seek 5 bytes before EOF, attempt to read much, get 5 bytes
reader.Seek(LongData.Length - 5, SeekOrigin.Begin);
int read = reader.Read(buf, 0, int.MaxValue);
Assert.AreEqual(5, read);
}
{ // read EOF
int read = reader.Read(buf, 0, int.MaxValue);
Assert.AreEqual(0, read);
}
{ // seek beyond stream length, read EOF
reader.Seek(LongData.Length * 3, SeekOrigin.Begin);
int read = reader.Read(buf, 0, int.MaxValue);
Assert.AreEqual(0, read);
}
{ // seek back, read again
reader.Seek(LongData.Length - 5, SeekOrigin.Begin);
int read = reader.Read(buf, 0, int.MaxValue);
Assert.AreEqual(5, read);
}
}
private bool LexRealNumber(StringBuilder start, char read)
{
CStreamReader sr = this.sr;
StringBuilder sb = start ?? new StringBuilder();
sb.Append(read);
loop:
read = (char)sr.Peek();
if (char.IsDigit(read))
{
sr.Read();
sb.Append(read);
goto loop;
}
read = char.ToLower(read);
if (read == 'e')
{
sr.Read();
return(LexRealNumberExponent(sb));
}
else if (read == 'f') // float
{
sr.Read();
return(PrsFLOAT(sb.Length, sb.ToString()));
}
else if (read == 'd')
{
sr.Read();
}
return(PrsDOUBLE(sb.Length, sb.ToString()));
}
private void CropImage()
{
if (InputImage1 == null)
{
return;
}
using (CStreamReader reader = InputImage1.CreateReader())
{
using (Bitmap bitmap = new Bitmap(reader))
{
int x1 = settings.SliderX1 * bitmap.Width / 10000;
int x2 = bitmap.Width - settings.SliderX2 * bitmap.Width / 10000 - x1;
int y1 = settings.SliderY1 * bitmap.Height / 10000;
int y2 = bitmap.Height - settings.SliderY2 * bitmap.Height / 10000 - y1;
Rectangle cropRect = new Rectangle(x1, y1, x2, y2);
Bitmap target = new Bitmap(cropRect.Width, cropRect.Height);
using (Graphics g = Graphics.FromImage(target))
{
g.DrawImage(bitmap, new Rectangle(0, 0, target.Width, target.Height),
cropRect,
GraphicsUnit.Pixel);
CreateOutputStream(target);
}
}
}
}
public void TestSeekSwap()
{
CStreamWriter writer = new CStreamWriter();
writer.Write(LongData);
CStreamReader reader = writer.CreateReader();
byte[] buf = new byte[1024];
// seek 5 bytes before EOF
reader.Seek(LongData.Length - 5, SeekOrigin.Begin);
// write more, ensure swap
writer.Write(LongData);
writer.Write(LongData);
Assert.IsTrue(writer.IsSwapped);
{ // seek somewhere to the middle, read
reader.Seek(LongData.Length * 2, SeekOrigin.Begin);
int read = reader.Read(buf);
Assert.AreEqual(buf.Length, read);
}
{ // seek beyond length, assert still open, get EOF
reader.Seek(LongData.Length * 3, SeekOrigin.Current);
Assert.IsFalse(writer.IsClosed);
int read = reader.Read(buf);
Assert.AreEqual(0, read);
}
}
public void TestExistingFileReader()
{
string tempFile = DirectoryHelper.GetNewTempFilePath();
FileStream tempWriter = new FileStream(tempFile, FileMode.CreateNew);
tempWriter.Write(ShortData, 0, ShortData.Length);
tempWriter.Write(LongData, 0, LongData.Length);
tempWriter.Close();
CStreamWriter cstream = new CStreamWriter(tempFile);
CStreamReader reader = cstream.CreateReader();
byte[] buf = new byte[ShortData.Length];
reader.ReadFully(buf);
Assert.IsTrue(buf.SequenceEqual(ShortData));
buf = new byte[LongData.Length];
reader.ReadFully(buf);
Assert.IsTrue(buf.SequenceEqual(LongData));
// force gc
reader = null;
cstream = null;
GC.Collect();
GC.WaitForPendingFinalizers();
File.Delete(tempFile);
}
public void TestSwapWithReader()
{
CStreamWriter writer = new CStreamWriter();
CStreamReader reader = writer.CreateReader();
// write, not swapped
writer.Write(LongData);
Assert.IsFalse(writer.IsSwapped);
// read a few bytes, but there are still a few bytes left
byte[] buf = new byte[ShortData.Length];
reader.Read(buf);
Assert.IsTrue(reader.Position > 0);
Assert.IsTrue(reader.Length > reader.Position);
// fill buffer, assert swap
writer.Write(LongData);
writer.Write(LongData);
Assert.IsTrue(writer.IsSwapped);
Assert.IsTrue(reader.IsSwapped);
// try to read more than available, receive less
buf = new byte[writer.Length * 2];
int read = reader.Read(buf);
Assert.IsTrue(read < buf.Length);
// close writer, assert EOF
writer.Close();
int result = reader.ReadByte();
Assert.AreEqual(-1, result);
}
private bool LexString()
{
CStreamReader sr = this.sr;
StringBuilder sb = new StringBuilder();
int numread = 2;
loop:
int read = sr.Read();
if (read == '\\') // unicode
{
int pos = LexUnicodeCHAR(sr, out read);
if (pos < 0)
{
return(false);
}
numread += pos;
sb.Append((char)read);
}
else if (read == '\"') // end
{
current = new Token(sb.ToString(), TokenType.literal_str, line, row);
row += numread;
return(true);
}
else
{
numread++;
sb.Append((char)read);
}
goto loop;
}
public void Execute()
{
if (InputStreamOne == null || InputStreamTwo == null)
{
return;
}
using (CStreamReader reader1 = InputStreamOne.CreateReader(), reader2 = InputStreamTwo.CreateReader())
{
outputStreamWriter = new CStreamWriter();
EventsHelper.PropertyChanged(PropertyChanged, this, "OutputStream");
int bytesRead;
byte[] buffer = new byte[1024];
// Input One
while ((bytesRead = reader1.Read(buffer)) > 0)
{
outputStreamWriter.Write(buffer, 0, bytesRead);
}
// Input Two
while ((bytesRead = reader2.Read(buffer)) > 0)
{
outputStreamWriter.Write(buffer, 0, bytesRead);
}
outputStreamWriter.Close();
}
}
private void initCipherInput()
{
long inputLength;
using (CStreamReader reader = CipherInput.CreateReader())
{
inputLength = reader.Length;
reader.Read(prelBlock);
reader.Read(cipherBlock);
reader.Close();
}
for (int byteCounter = 0; byteCounter < blockSize; byteCounter++)
{
corruptedBlock[byteCounter] = prelBlock[byteCounter];
}
if (inputLength < 2 * blockSize)
{
curState = STATES.ERROR;
GuiLogMessage("Input Message too short. Please check if the Block Size is correct (in the Plugin Settings).", NotificationLevel.Error);
}
else if (inputLength > 2 * blockSize)
{
GuiLogMessage("The input message is longer than the expected length. Please check if the Block Size is correct (in the Plugin Settings).", NotificationLevel.Warning);
}
}
public void Execute()
{
ProgressChanged(0.5, 1.0);
if (inputData != null)
{
if (Presentation.IsVisible)
{
md5.Initialize(inputData);
}
else
{
HashAlgorithm builtinMd5 = System.Security.Cryptography.MD5.Create();
using (CStreamReader reader = inputData.CreateReader())
{
OutputData = builtinMd5.ComputeHash(reader);
}
ProgressChanged(1.0, 1.0);
}
}
else
{
GuiLogMessage("Received null value for CryptoolStream.", NotificationLevel.Warning);
}
}
public void Execute()
{
if (InputStream != null)
{
using (CStreamReader reader = InputStream.CreateReader())
{
reader.WaitEof();
if (reader.Length > settings.MaxLength)
{
ShowStatusBarMessage("WARNING - Input 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[] buffer = new byte[Math.Min(reader.Length, settings.MaxLength)];
reader.Seek(0, SeekOrigin.Begin);
reader.Read(buffer, 0, buffer.Length);
processInput(buffer);
}
}
else if (InputBytes != null)
{
processInput(InputBytes);
}
else
{
ShowStatusBarMessage("Inputs are null. Nothing to convert.", NotificationLevel.Warning);
}
}
public void TestReader()
{
CStreamWriter writer = new CStreamWriter();
// put 6 bytes
writer.Write(ShortData);
CStreamReader reader = writer.CreateReader();
// length==6, position==0
Assert.AreEqual(0, reader.Position);
Assert.AreEqual(ShortData.Length, reader.Length);
// try to read more bytes than available
byte[] buf = new byte[ShortData.Length * 1000];
Assert.AreNotEqual(buf.Length, ShortData.Length);
Assert.IsFalse(buf.SequenceEqual(ShortData));
int read = reader.Read(buf);
Assert.AreEqual(ShortData.Length, read);
// assert the first few bytes are still correct
byte[] buf2 = new byte[ShortData.Length];
Array.Copy(buf, buf2, buf2.Length);
Assert.IsTrue(buf2.SequenceEqual(ShortData));
// not swapped
Assert.IsFalse(reader.IsSwapped);
}
public void Execute()
{
Progress(0.5, 1.0);
if (inputData != null && inputData.Length >= 0)
{
System.Security.Cryptography.RIPEMD160 ripeMd160Hash = System.Security.Cryptography.RIPEMD160.Create();
using (CStreamReader reader = inputData.CreateReader())
{
OutputData = ripeMd160Hash.ComputeHash(reader);
}
GuiLogMessage("Hash created.", NotificationLevel.Info);
Progress(1, 1);
}
else
{
if (inputData == null)
{
GuiLogMessage("Received null value for CryptoolStream.", NotificationLevel.Warning);
}
else
{
GuiLogMessage("No input stream.", NotificationLevel.Warning);
}
}
Progress(1.0, 1.0);
}
// private bool ParseType(string text)
// {
// CStreamReader sr = this.sr;
//
// if (sr.Peek() == '[' && sr.Peek(1) == ']')
// {
// StringBuilder sbLR = new StringBuilder();
// sbLR.Append("[]");
//
// int idx = 2;
//
// loop2:
// if (sr.Peek(idx) == '[')
// if (sr.Peek(idx + 1) == ']')
// {
// idx += 2;
// sbLR.Append("[]");
// goto loop2;
// }
// else
// {
// handler.Fail(FMSG.F1);
// return true; // 강제 반환
// }
//
// sr.Move(idx);
//
// current = new Token(text, TokenType.type_array, line, row, idx / 2);
// row += idx;
//
// return true;
// }
//
// current = new Token(text, TokenType.type, line, row);
// return false;
// }
private int LexIdentity(char read, out string result)
{
StringBuilder sb = new StringBuilder();
int tmprow;
if (read != '@')
{
tmprow = 1;
sb.Append(read);
}
else
{
tmprow = 0;
}
CStreamReader sr = this.sr;
loop:
read = (char)sr.Peek();
if (char.IsLetterOrDigit(read) || read == '_')
{
sr.Read();
sb.Append(read);
tmprow++;
goto loop;
}
result = sb.ToString();
return(tmprow);
}
private byte[] CStreamReaderToByteArray(CStreamReader stream)
{
stream.WaitEof();
byte[] buffer = new byte[stream.Length];
stream.Seek(0, System.IO.SeekOrigin.Begin);
stream.ReadFully(buffer);
return(buffer);
}
/// <summary>
/// Called every time this plugin is run in the workflow execution.
/// </summary>
public void Execute()
{
// The following variables follow the same naming convention used in the
// specification:
// l: length of each message block, in bits.
// t: number of blocks the whole message uses.
// T: total number of blocks.
// N: number of bits in the input message.
// w: number of zeroes for padding.
int l = bufferSize * 8;
ulong t = 0;
ulong T = 0;
ulong N = 0;
ulong w = 0;
byte[] h = new byte[bufferSize];
System.Array.Copy(IV, h, bufferSize);
ProgressChanged(0, 1);
using (CStreamReader reader = InputStream.CreateReader())
{
int bytesRead;
byte[] buffer = new byte[bufferSize];
while ((bytesRead = reader.ReadFully(buffer)) == bufferSize)
{
N = N + (ulong)bytesRead * 8;
h = Compression(h, buffer);
t = t + 1;
}
ProgressChanged(0.8, 1);
N = N + (ulong)bytesRead * 8;
w = (ulong)((((-(long)N - 65) % l) + l) % l);
T = (N + w + 65) / (ulong)l;
int blocksLeft = (int)(T - t);
buffer[bytesRead] = 0x80;
int numberOfZeroBytes = bufferSize - bytesRead - 1;
byte[] zeroes = new byte[numberOfZeroBytes];
System.Array.Copy(zeroes, 0, buffer, bytesRead + 1, numberOfZeroBytes);
for (uint i = 0; i < blocksLeft; i++)
{
if (i == blocksLeft - 1)
{
byte[] bytes = System.BitConverter.GetBytes((ulong)T);
if (System.BitConverter.IsLittleEndian)
{
System.Array.Reverse(bytes);
}
System.Array.Copy(bytes, 0, buffer, bufferSize - 8, 8);
}
h = Compression(h, buffer);
buffer = new byte[bufferSize];
}
h = Truncation(XOR(P(h), h));
OutputData = h;
}
ProgressChanged(1, 1);
}
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));
}
}
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);
}
/// <summary>
/// HOWTO: Enter the algorithm you'd like to implement in this method.
/// </summary>
public void Execute()
{
// no progress, yet
ProgressChanged(0, 1);
if (InputCarrier == null)
{
GuiLogMessage("Please specify an input file.", NotificationLevel.Error);
return;
}
using (CStreamReader midiReader = InputCarrier.CreateReader())
{
MemoryStream secretStream;
MemoryStream outputStream = new MemoryStream();
MidiFileHandler midiHandler = new MidiFileHandler();
switch (settings.Action)
{
case 0: // Encryption
using (CStreamReader messageReader = InputData.CreateReader())
{
secretStream = new MemoryStream(messageReader.ReadFully());
midiHandler.HideOrExtract(midiReader, secretStream, new MemoryStream(), outputStream, (byte)(settings.MaxMessageBytesPerCarrierUnit * 2), false);
}
OutputCarrier = new CStreamWriter(outputStream.ToArray());
OnPropertyChanged("OutputCarrier");
break;
case 1: // Decryption
secretStream = new MemoryStream();
midiHandler.HideOrExtract(midiReader, secretStream, new MemoryStream(), outputStream, 1, true);
//OutputData = new CStreamWriter(secretStream.GetBuffer());
secretStream.Position = 0;
using (StreamReader secretReader = new StreamReader(secretStream))
{
OutputText = secretReader.ReadToEnd();
OnPropertyChanged("OutputText");
}
break;
}
}
// 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.
//if (settings.Subtrahend < 0)
// GuiLogMessage("Subtrahend is negative", NotificationLevel.Debug);
// HOWTO: Make sure the progress bar is at maximum when your Execute() finished successfully.
ProgressChanged(1, 1);
}
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);
}
public static byte[] ToByteArray(this CStreamReader stream)
{
if (stream == null)
{
return(new byte[0]);
}
stream.WaitEof();
byte[] buffer = new byte[stream.Length];
stream.Seek(0, System.IO.SeekOrigin.Begin);
stream.ReadFully(buffer);
return(buffer);
}
protected virtual void OnNormalAction(string current, CStreamReader input, StreamWriter output)
{
int idx = current.IndexOf("//");
if (idx >= 0)
{
output.Write(current.Substring(0, idx).Trim() + Environment.NewLine); // 끝 주석때문에 newline 필요
}
idx = current.IndexOf("/*");
if (idx >= 0)
{
int cnt = 1;
int max = current.Length - 1;
StringBuilder builder = new StringBuilder(max - 3);
builder.Append(current.Substring(0, idx).Trim());
int begin = 0;
for (; idx < max; idx += 2)
{
char f1 = current[idx];
char f2 = current[idx + 1];
if (f1 == '/' && f2 == '*')
{
builder.Append(current.Substring(begin, idx).Trim());
cnt++;
}
else if (f1 == '*' && f2 == '/')
{
cnt--;
if (cnt == 0)
{
begin = idx + 2;
}
}
}
string temp = builder.ToString();
if (FnCHAR.IsNewLine(temp[builder.Length - 1]))
{
output.Write(temp);
}
else
{
output.Write(temp + Environment.NewLine);
}
}
else
{
output.Write(current);
}
}
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);
}
public void TestDestructorWithReader()
{
CStreamWriter writer = new CStreamWriter();
// write, not swapped
writer.Write(LongData);
// read something and assert there's more
CStreamReader reader = writer.CreateReader();
byte[] buf = new byte[ShortData.Length];
reader.Read(buf);
Assert.IsTrue(reader.Position > 0);
Assert.IsTrue(reader.Length > reader.Position);
Assert.IsFalse(reader.IsSwapped);
// write more, assert swap
writer.Write(LongData);
writer.Write(LongData);
Assert.IsTrue(reader.IsSwapped);
string filePath = writer.FilePath;
// destroy ref to writer
writer.Close();
writer = null;
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.IsNull(writer);
// assert reading still works
Assert.IsTrue(File.Exists(filePath));
Assert.IsNotNull(reader);
int sum = 0;
while (sum < LongData.Length * 2)
{
int read = reader.Read(buf);
Assert.IsTrue(read > 0);
sum += read;
}
// destroy reader
reader = null;
GC.Collect();
GC.WaitForPendingFinalizers();
// deleted tempfile
Assert.IsFalse(File.Exists(filePath));
}
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());
}
}
/// <summary>
/// Read the next byte of the key stream.
/// Reset the stream if it is too short.
/// </summary>
/// <returns>The next key byte</returns>
protected byte GetKeyValue(CStreamReader keyStream)
{
int keyValue = 0;
if (keyStream.Length > 0)
{
if ((keyValue = keyStream.ReadByte()) < 0)
{
keyStream.Seek(0, SeekOrigin.Begin);
keyValue = keyStream.ReadByte();
}
}
return((byte)keyValue);
}
private string DetectInvisibleWatermark() //Extract invisible watermark
{
water = new Watermark(_boxSize, _errorCorrection, _opacity, _s1, _s2);
using (CStreamReader reader = InputPicture.CreateReader())
{
using (Bitmap bitmap = new Bitmap(reader))
{
if (_stopped)
{
return("");
}
return(water.extractText(bitmap));
}
}
}
public void TestExhaustiveRead()
{
CStreamWriter writer = new CStreamWriter();
writer.Write(LongData);
writer.Write(LongData);
writer.Write(LongData);
writer.Close();
CStreamReader reader = writer.CreateReader();
byte[] bigbuf = reader.ReadFully();
Assert.AreEqual(LongData.Length * 3, bigbuf.Length);
}
public ScanActionEnumerator(
CStreamReader sr,
IEnumeratorPair <string, TokenType> sys,
IEnumeratorPair <string, TokenType> ids,
IExceptionHandler handler,
ITypeMap typeMap)
{
this.sys = sys;
this.ids = ids;
this.sr = sr;
this.handler = handler;
this.typeMap = typeMap;
line = 1;
sample_row = row = 1;
}
