/// <summary>
/// Calculates the CRC32 polynomial of an object.
/// </summary>
/// <param name="value">The object to check.</param>
/// <returns>A checksum of <paramref name="value"/> as an integer.</returns>
public static long CRC32(object value)
{
var raw = ToByteArray(value);
var alg = new CRC32();
alg.ComputeHash(raw);
return alg.Value;
}
/// <summary>
/// Метод возвращает строку, которая представляет хеш-сумму файла по указанному пути для алгоритма CRC-32.
/// </summary>
/// <returns></returns>
public string GetCRCHash()
{
CRC32 crc32 = new CRC32();
String hash = String.Empty;
try
{
using (FileStream fs = File.Open(filePath, FileMode.Open))
foreach (byte b in crc32.ComputeHash(fs))
hash += b.ToString("x2").ToLower();
}
catch (Exception e)
{
System.Windows.MessageBox.Show(e.Message);
}
return hash;
}
private byte[] getCrc32(byte[] data, long dataLength) {
CRC32 crc32 = new CRC32();
crc32.Initialize();
byte[] hash = crc32.ComputeHash(data, 0, (int)dataLength);
Array.Reverse(hash);
return hash;
}
private void NetworkLoop()
{
while (!Cancellator.IsCancellationRequested)
{
try
{
if (!Socket.Poll(100000, SelectMode.SelectRead))
{
continue;
}
}
catch (SocketException) { break; }
byte[] Data;
try
{
byte[] Buffer = new byte[8];
Stream.Read(Buffer, 0, 8);
int PacketLength = ToInt32(Buffer, 0);
if (ToUInt32(Buffer, 4) != 0x31305456U)
{
break;
}
Data = new byte[PacketLength];
int Offset = 0;
do
{
int BytesRead = Stream.Read(Data, Offset, PacketLength);
if (BytesRead == 0)
{
break;
}
Offset += BytesRead;
PacketLength -= BytesRead;
} while (PacketLength > 0);
if (PacketLength != 0)
{
break;
}
}
catch (IOException) { break; }
try
{
if (State == EncryptionState.Encrypted)
{
MessageReceived(Encryptor.Decrypt(Data));
}
else
{
MessageType Type = MessageType.Invalid;
if (Data.Length > 3)
{
Type = (MessageType)(ToUInt32(Data, 0) & ~0x80000000U);
}
if (State == EncryptionState.Connected && Type == MessageType.ChannelEncrypt)
{
RawMessage <ChannelEncrypt> Message = new RawMessage <ChannelEncrypt>(Data);
if (Message.Payload.Length >= 16)
{
RawMessage <ChannelEncrypt> Response = new RawMessage <ChannelEncrypt>(MessageType.ChannelEncryptResponse);
byte[] Challenge = Message.Payload, EncryptedBlob, SessionKey = new byte[32];
using (RandomNumberGenerator RNG = RandomNumberGenerator.Create())
RNG.GetBytes(SessionKey);
using (RSA RSA = RSA.Create())
{
RSA.ImportParameters(Parameters);
byte[] BlobToEncrypt = new byte[32 + Challenge.Length];
Copy(SessionKey, BlobToEncrypt, 32);
Copy(Challenge, 0, BlobToEncrypt, 32, Challenge.Length);
EncryptedBlob = RSA.Encrypt(BlobToEncrypt, RSAEncryptionPadding.OaepSHA1);
}
byte[] CRCHash;
using (CRC32 CRC = new CRC32())
CRCHash = CRC.ComputeHash(EncryptedBlob);
int Length = EncryptedBlob.Length;
Response.Payload = new byte[Length + 8];
Copy(EncryptedBlob, Response.Payload, Length);
Copy(CRCHash, 0, Response.Payload, Length, 4);
Encryptor = new EncryptionFilter(SessionKey);
State = EncryptionState.Challenged;
Send(Response.Serialize());
}
else
{
Disconnect(false);
}
}
else if (State == EncryptionState.Challenged && Type == MessageType.ChannelEncryptResult)
{
if (new RawMessage <ChannelEncryptResult>(Data).Body.Success)
{
State = EncryptionState.Encrypted;
Log($"Established encrypted TCP connection to {EndpointAddress}");
Connected?.Invoke();
}
else
{
Disconnect(false);
}
}
else
{
Disconnect(false);
}
}
}
catch { }
}
bool UserInitiated = Cancellator.IsCancellationRequested;
if (UserInitiated)
{
Shutdown();
}
Release(UserInitiated);
}
/// <summary>
/// The sender then sends a ZFILE header with ZMODEM Conversion, Management, and Transport options[3]
/// followed by a ZCRCW data subpacket containing the file name, file length,
/// modification date, and other information identical to that used by YMODEM Batch.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="crcCalculator"></param>
private bool SendZFILEHeaderCommand(string filename, int length, DateTimeOffset lastWriteTimeUtc, CRC32 crcCalculator)
{
var result = default(bool);
var isExtended = true;
var zFileHeader = Utils.Build32BitBinHeader(
HeaderType.ZFILE,
ZFILEConversionOption.ZCBIN,
ZFILEManagementOption.ZMNEWL,
ZFILETransportOption.None,
ZFILEExtendedOptions.None,
crcCalculator
);
var zFileHeaderQueue = new Queue <byte>();
foreach (var c in zFileHeader)
{
zFileHeaderQueue.Enqueue((byte)c);
}
// Send ZFILE header first - No response
SendCommand(zFileHeaderQueue.ToArray());
var dataQueue = new Queue <byte>();
foreach (char c in filename)
{
dataQueue.Enqueue((byte)c);
}
if (isExtended)
{
dataQueue.Enqueue(0);
// File length as decimal string
var fileLength = length.ToString();
foreach (var c in fileLength)
{
dataQueue.Enqueue((byte)c);
}
// Space
dataQueue.Enqueue(0x20);
var utcTime = lastWriteTimeUtc.ToUnixTimeSeconds();
var octalString = Convert.ToString(utcTime, 8);
// Modification date
foreach (var c in octalString)
{
dataQueue.Enqueue((byte)c);
}
}
else
{
// The file information is terminated by a null.
// If only the pathname is sent, the pathname is terminated with two nulls.
dataQueue.Enqueue(0);
dataQueue.Enqueue(0);
}
byte[] data = dataQueue.Concat(new byte[] { (byte)ZDLESequence.ZCRCW }).ToArray();
dataQueue.Enqueue((byte)ControlBytes.ZDLE);
dataQueue.Enqueue((byte)ZDLESequence.ZCRCW);
var crc = crcCalculator.ComputeHash(data);
var encodedCRC = dataQueue
.Concat(ZDLEEncoder.EscapeControlCharacters(crc))
.ToArray();
var response = SendCommand(encodedCRC, true, HeaderType.ZRPOS);
// We expect ZRPOS
if (response?.ZHeader == HeaderType.ZRPOS)
{
result = true;
}
/*
* The receiver may respond with a ZSKIP header, which makes the sender
* proceed to the next file (if any) in the batch.
*
* A ZRPOS header from the receiver initiates transmission of the file
* data starting at the offset in the file specified in the ZRPOS header.
* Normally the receiver specifies the data transfer to begin begin at
* offset 0 in the file.
*/
if (response?.ZHeader == HeaderType.ZSKIP ||
response?.ZHeader == HeaderType.ZRPOS ||
response?.ZHeader == HeaderType.ZCRC)
{
/*
* The receiver has a file with the same name and length, may
* respond with a ZCRC header with a byte count, which
* requires the sender to perform a 32 bit CRC on the
* specified number of bytes in the file and transmit the
* complement of the CRC in an answering ZCRC header.the crc is
* initialised to 0xfffffff; a byte count of 0 implies the entire
* file the receiver uses this information to determine whether to
* accept the file or skip it. This sequence may be triggered
* by the ZMCRC Management Option.
*/
}
return(result);
}
public void SampleEncode()
{
FileStream fs = File.OpenRead(@"..\..\Samples\TestFile.bin");
try
{
byte[] original = new byte[4096];
int originalBytes = fs.Read(original, 0, 4096);
Assert.AreEqual(584, originalBytes, "Unexpected amount of bytes read.");
//test file encodes period(46) and tab(9), and follows with CRLF
YEncEncoder encoder = new YEncEncoder(128, new byte[] {46,9}, true);
byte[] encoded = new byte[4096];
int encodedBytes = encoder.GetBytes(original, 0, originalBytes, encoded, 0, true);
Assert.AreEqual(606, encodedBytes, "Test file supplied encodes to 606");
FileStream fs2 = File.OpenRead(@"..\..\Samples\Encoded.bin");
try
{
byte[] check = new byte[4096];
int checkBytes = fs2.Read(check, 0, 4096);
Assert.AreEqual(606, checkBytes, "We expect 606 bytes");
for(int i=0; i<checkBytes; i++)
{
Assert.AreEqual(check[i], encoded[i], "Checked against sample encoded failed on byte " + i.ToString());
}
CRC32 extraCheck = new CRC32();
extraCheck.ComputeHash(original, 0, originalBytes);
byte[] extraCheckCRC = extraCheck.Hash;
byte[] actualCRC = encoder.CRCHash;
byte[] expectedCRC = new byte[] {0xde,0xd2,0x9f,0x4f};
Assert.AreEqual(BitConverter.ToString(expectedCRC), BitConverter.ToString(extraCheckCRC), "CRC mismatch, due to CRC algorithm failure?");
Assert.AreEqual(BitConverter.ToString(expectedCRC), BitConverter.ToString(actualCRC), "CRC mismatch");
}
finally
{
fs2.Close();
}
}
finally
{
fs.Close();
}
}
public override unsafe void CodeImage(Bitmap bitmap, Stream outStream)
{
lock (ImageProcessLock)
{
if (!outStream.CanWrite)
{
throw new Exception("Must have access to Write in the Stream");
}
if (LastFrame == null)
{
byte[] temp = base.jpgCompression.Compress(bitmap);
outStream.Write(BitConverter.GetBytes(temp.Length), 0, 4);
outStream.Write(temp, 0, temp.Length);
SetLastFrame(ref bitmap);
return;
}
long oldPos = outStream.Position;
outStream.Write(new byte[4], 0, 4);
int TotalDataLength = 0;
List <byte[]> updates = new List <byte[]>();
SimpleBitmap sbBmp = new SimpleBitmap(bitmap);
MemoryStream ms = new MemoryStream();
byte[] buffer = null;
if (!LastFrame.Locked)
{
LastFrame.Lock();
}
sbBmp.Lock();
if (sbBmp.Info.PixelSize != LastFrame.Info.PixelSize)
{
throw new Exception("PixelFormat is not equal to previous Bitmap");
}
if (LastFrame.Info.Width != sbBmp.Info.Width || LastFrame.Info.Height != sbBmp.Info.Height)
{
sbBmp.Unlock();
throw new Exception("Bitmap width/height are not equal to previous bitmap");
}
List <Rectangle> Blocks = new List <Rectangle>();
int index = 0;
int y = 0;
int x = 0;
Size s = new Size(bitmap.Width, CheckBlock.Height);
Size lastSize = new Size(bitmap.Width % CheckBlock.Width, bitmap.Height % CheckBlock.Height);
int lasty = bitmap.Height - lastSize.Height;
int lastx = bitmap.Width - lastSize.Width;
Rectangle cBlock = new Rectangle();
s = new Size(bitmap.Width, s.Height);
while (y != bitmap.Height)
{
if (y == lasty)
{
s = new Size(bitmap.Width, lastSize.Height);
}
cBlock = new Rectangle(0, y, bitmap.Width, s.Height);
if (onCodeDebugScan != null)
{
onCodeDebugScan(cBlock);
}
if (!SimpleBitmap.Compare(cBlock, LastFrame.Scan0_int, sbBmp.Scan0_int, sbBmp.Info))
//if (!SimpleBitmap.Compare(y, s.Height, LastFrame.Scan0_int, sbBmp.Scan0_int, sbBmp.Info))
{
index = Blocks.Count - 1;
if (Blocks.Count != 0 && (Blocks[index].Y + Blocks[index].Height) == cBlock.Y)
{
cBlock = new Rectangle(Blocks[index].X, Blocks[index].Y, Blocks[index].Width, Blocks[index].Height + cBlock.Height);
Blocks[index] = cBlock;
}
else
{
Blocks.Add(cBlock);
}
}
y += s.Height;
}
List <CacheInfo> finalUpdates = new List <CacheInfo>();
const int CheckHeight = 50;
for (int i = 0; i < Blocks.Count; i++)
{
s = new Size(CheckBlock.Width, Blocks[i].Height);
y = Blocks[i].Y;
lasty = (Blocks[i].Y + Blocks[i].Height);
while (y != lasty)
{
int ScanHeight = y + CheckHeight > lasty ? lasty - y : CheckHeight;
x = 0;
while (x != bitmap.Width)
{
if (x == lastx)
{
s = new Size(lastSize.Width, Blocks[i].Height);
}
cBlock = new Rectangle(x, y, s.Width, ScanHeight);
if (onCodeDebugScan != null)
{
onCodeDebugScan(cBlock);
}
if (!SimpleBitmap.Compare(cBlock, sbBmp.Scan0_int, LastFrame.Scan0_int, sbBmp.Info))
{
/*byte[] tempData = new byte[0];
* LastFrame.CopyBlock(cBlock, ref tempData);
* finalUpdates.Add(new CacheInfo(0, false, tempData, cBlock));*/
//hash it and see if exists in cache
hasher = new CRC32(); //re-initialize for seed
byte[] tempData = new byte[0];
LastFrame.CopyBlock(cBlock, ref tempData);
int hash = BitConverter.ToInt32(hasher.ComputeHash(tempData), 0);
if (codeCached.Count >= MaxBuffers)
{
codeCached.RemoveAt(0);
}
if (codeCached.ContainsKey(hash))
{
CachedSize += (ulong)tempData.Length;
finalUpdates.Add(new CacheInfo(hash, true, new byte[0], cBlock));
}
else
{
//nothing found in cache let's use the normal way
codeCached.Add(hash, tempData);
finalUpdates.Add(new CacheInfo(hash, false, tempData, cBlock));
}
}
x += s.Width;
}
y += ScanHeight;
}
}
for (int i = 0; i < finalUpdates.Count; i++)
{
buffer = new byte[0];
Rectangle rect = finalUpdates[i].Rect;
if (!finalUpdates[i].isCached)
{
fixed(byte *ptr = finalUpdates[i].Data)
{
using (Bitmap TmpBmp = new Bitmap(rect.Width, rect.Height, rect.Width * LastFrame.Info.PixelSize, LastFrame.bitmapData.PixelFormat, new IntPtr(ptr)))
{
buffer = base.jpgCompression.Compress(TmpBmp);
}
}
}
outStream.WriteByte(finalUpdates[i].isCached ? (byte)1 : (byte)0);
outStream.Write(BitConverter.GetBytes(finalUpdates[i].Rect.X), 0, 4);
outStream.Write(BitConverter.GetBytes(finalUpdates[i].Rect.Y), 0, 4);
outStream.Write(BitConverter.GetBytes(finalUpdates[i].Rect.Width), 0, 4);
outStream.Write(BitConverter.GetBytes(finalUpdates[i].Rect.Height), 0, 4);
outStream.Write(BitConverter.GetBytes(finalUpdates[i].Hash), 0, 4);
outStream.Write(BitConverter.GetBytes(buffer.Length), 0, 4);
outStream.Write(buffer, 0, buffer.Length);
TotalDataLength += buffer.Length + (4 * 6) + 1;
}
outStream.Position = oldPos;
outStream.Write(BitConverter.GetBytes(TotalDataLength), 0, 4);
Blocks.Clear();
SetLastFrame(sbBmp);
ms.Close();
ms.Dispose();
}
}
/// <see cref="IHeap.ComputeHash"/>
public byte[] ComputeHash()
{
return(CRC32.ComputeHash(this.GetByteSquence()));
}
public static string CalcCRC32(string password)
{
return(BitConverter.ToInt32(crc32.ComputeHash(Encoding.UTF8.GetBytes(password)), 0).ToString());
}
public static uint GetCRC32(Stream input)
{
byte[] data = crc32.ComputeHash(input);
return(GetCRC32(data));
}
private static string getUniqueIdentifier(byte[] replayDataBuffer)
{
CRC32 crc = new CRC32();
byte[] tailInBytes = crc.ComputeHash(replayDataBuffer);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < tailInBytes.Length; i++)
{
sb.Append(tailInBytes[i].ToString("x2"));
}
string tail = sb.ToString();
return tail;
}
public override unsafe void CodeImage(Bitmap bitmap, Stream outStream)
{
if (!outStream.CanWrite)
{
throw new Exception("Must have access to Write in the Stream");
}
if (CodeTempBitmap != null)
{
if (CodeTempBitmap.Width != bitmap.Width || CodeTempBitmap.Height != bitmap.Height)
{
throw new Exception("Bitmap width/height are not equal to previous bitmap");
}
if (bitmap.PixelFormat != CodeTempBitmap.PixelFormat)
{
throw new Exception("PixelFormat is not equal to previous Bitmap");
}
}
if (CodeTempBitmap == null)
{
byte[] temp = base.jpgCompression.Compress(bitmap);
outStream.Write(BitConverter.GetBytes(temp.Length), 0, 4);
outStream.Write(temp, 0, temp.Length);
CodeTempBitmap = bitmap;
return;
}
BitmapData bmpData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
BitmapData CodeBmpData = CodeTempBitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
int Stride = Math.Abs(bmpData.Stride);
List <Rectangle> Blocks = new List <Rectangle>();
for (int y = 0, i = 0; y < bitmap.Height; y++, i += Stride)
{
if (onCodeDebugScan != null)
{
onCodeDebugScan(new Rectangle(0, y, bitmap.Width, 1));
}
Rectangle ScanBlock = new Rectangle(0, y, bitmap.Width, 1);
if (NativeMethods.memcmp(new IntPtr(bmpData.Scan0.ToInt32() + i), new IntPtr(CodeBmpData.Scan0.ToInt32() + i), (uint)Stride) != 0)
{
byte[] temp = new byte[Stride];
fixed(byte *ptr = temp)
{
NativeMethods.memcpy(ptr, (void *)(bmpData.Scan0.ToInt32() + i), (uint)temp.Length);
}
CRC32 hasher = new CRC32();
int hash = BitConverter.ToInt32(hasher.ComputeHash(temp), 0);
if (EncodeCache.Count >= MaxBuffers)
{
EncodeCache.RemoveAt(0);
}
if (EncodeCache.ContainsKey(hash))
{
outStream.WriteByte(1);
outStream.Write(new byte[4], 0, 4);
outStream.Write(BitConverter.GetBytes(hash), 0, 4);
outStream.Write(BitConverter.GetBytes((ushort)y), 0, 2);
}
else
{
outStream.WriteByte(0);
outStream.Write(BitConverter.GetBytes(temp.Length), 0, 4);
outStream.Write(BitConverter.GetBytes(hash), 0, 4);
outStream.Write(BitConverter.GetBytes((ushort)y), 0, 2);
outStream.Write(temp, 0, temp.Length);
EncodeCache.Add(hash, temp);
}
Blocks.Add(ScanBlock);
}
}
for (int i = 0; i < Blocks.Count; i++)
{
Bitmap cloned = (Bitmap)bitmap.Clone(Blocks[i], bitmap.PixelFormat);
byte[] temp = base.jpgCompression.Compress(cloned);
cloned.Dispose();
}
bitmap.UnlockBits(bmpData);
CodeTempBitmap.UnlockBits(CodeBmpData);
if (onVideoStreamCoding != null)
{
onVideoStreamCoding(outStream, Blocks.ToArray());
}
if (CodeTempBitmap != null)
{
CodeTempBitmap.Dispose();
}
this.CodeTempBitmap = bitmap;
}