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; }