public void TestAsHexNoDelimiterLower()
{
byte[] before = GetRandomBytes(200, 300);
BinaryResults res = new EncryptionResults(before);
string after = res.AsHex(false, null);
var expected = new StringBuilder();
foreach (byte b in before)
{
expected.Append(b.ToString("x2"));
}
Assert.AreEqual(expected.ToString(), after);
res = new DecryptionResults(before);
after = res.AsHex(false, null);
expected = new StringBuilder();
foreach (byte b in before)
{
expected.Append(b.ToString("x2"));
}
Assert.AreEqual(expected.ToString(), after);
res = new HashResults(before);
after = res.AsHex(false, null);
expected = new StringBuilder();
foreach (byte b in before)
{
expected.Append(b.ToString("x2"));
}
Assert.AreEqual(expected.ToString(), after);
}
public void TestAsAscii85()
{
byte[] before = GetRandomBytes(200, 300);
BinaryResults res = new EncryptionResults(before);
string after = res.AsAscii85();
Assert.IsTrue(Ascii85Converter.BytesToAscii85(before).SequenceEqual(after));
res = new DecryptionResults(before);
after = res.AsAscii85();
Assert.IsTrue(Ascii85Converter.BytesToAscii85(before).SequenceEqual(after));
res = new HashResults(before);
after = res.AsAscii85();
Assert.IsTrue(Ascii85Converter.BytesToAscii85(before).SequenceEqual(after));
}
public void TestAsBase64()
{
byte[] before = GetRandomBytes(200, 300);
BinaryResults res = new EncryptionResults(before);
string after = res.AsBase64();
Assert.IsTrue(Convert.ToBase64String(before).SequenceEqual(after));
res = new DecryptionResults(before);
after = res.AsBase64();
Assert.IsTrue(Convert.ToBase64String(before).SequenceEqual(after));
res = new HashResults(before);
after = res.AsBase64();
Assert.IsTrue(Convert.ToBase64String(before).SequenceEqual(after));
}
public void TestAsBytes()
{
byte[] before = GetRandomBytes(200, 300);
BinaryResults res = new EncryptionResults(before);
byte[] after = res.AsBytes();
Assert.IsTrue(before.SequenceEqual(after));
res = new DecryptionResults(before);
after = res.AsBytes();
Assert.IsTrue(before.SequenceEqual(after));
res = new HashResults(before);
after = res.AsBytes();
Assert.IsTrue(before.SequenceEqual(after));
}
public void TestAsHexDelimiterUpper()
{
byte[] before = GetRandomBytes(200, 300);
BinaryResults res = new EncryptionResults(before);
string after = res.AsHex(true, '+');
var expected = new StringBuilder();
foreach (byte b in before)
{
if (expected.Length > 0)
{
expected.Append("+");
}
expected.Append(b.ToString("X2"));
}
Assert.AreEqual(expected.ToString(), after);
res = new DecryptionResults(before);
after = res.AsHex(true, '+');
expected = new StringBuilder();
foreach (byte b in before)
{
if (expected.Length > 0)
{
expected.Append("+");
}
expected.Append(b.ToString("X2"));
}
Assert.AreEqual(expected.ToString(), after);
res = new HashResults(before);
after = res.AsHex(true, '+');
expected = new StringBuilder();
foreach (byte b in before)
{
if (expected.Length > 0)
{
expected.Append("+");
}
expected.Append(b.ToString("X2"));
}
Assert.AreEqual(expected.ToString(), after);
}
private void WriteFileHash(string path, HashResults hr)
{
if (null == hr)
{
return;
}
var sb = new StringBuilder();
sb.AppendLine(path);
sb.Append("Size: ");
sb.Append(hr.size.ToString());
sb.AppendLine();
WriteFileHashWithAlg(sb, "CRC32", hr.crc32);
WriteFileHashWithAlg(sb, "SHA256", hr.sha256);
sb.AppendLine();
var s = sb.ToString();
File.AppendAllText(this.mHashFile, s);
}
private void RefreshFile(string path)
{
this.CheckHddTemperature();
while ((this.mIsPaused || this.mIsCoolDown) && this.mRunning)
{
Thread.Sleep(250);
}
if (!this.mRunning)
{
return;
}
if (path.Equals(this.mTmpFile, StringComparison.OrdinalIgnoreCase) ||
path.Equals(this.mHashFile, StringComparison.OrdinalIgnoreCase)
)
{
return;
}
if (path.IndexOf(":\\$RECYCLE.BIN", StringComparison.OrdinalIgnoreCase) > 0 ||
path.IndexOf(":\\System Volume Information", StringComparison.OrdinalIgnoreCase) > 0 ||
path.EndsWith("\\desktop.ini", StringComparison.OrdinalIgnoreCase)
)
{
return;
}
this.SetCurrentFile(path);
var handle = OpenFileForReading(path);
var ok = IsValidFileHandle(handle);
var size = (long)0;
if (ok)
{
ok = GetFileSizeEx(handle, out size);
if (!ok)
{
size = 0;
}
}
this.SetProgressBarMaxValue(this.PrgbCurrentFile, size);
var hr = (HashResults)null;
var enableHash = (size >= this.mMinHashFileSize);
if (enableHash)
{
hr = new HashResults();
hr.size = size;
}
var fileYearsOld = this.mMaxFileYearsOld;
if (fileYearsOld >= 0)
{
fileYearsOld = this.mCurrentYear - fileYearsOld;
}
var fileTimeOK = false;
var creationTime = new FILETIME();
var lastAccessTime = new FILETIME();
var lastWriteTime = new FILETIME();
var lastWriteSystemTime = new SYSTEMTIME();
if (ok)
{
while (true)
{
fileTimeOK = GetFileTime(handle, ref creationTime, ref lastAccessTime, ref lastWriteTime);
if (!fileTimeOK)
{
break;
}
if (fileYearsOld < 0)
{
break;
}
fileTimeOK = FileTimeToSystemTime(ref lastWriteTime, out lastWriteSystemTime);
if (!fileTimeOK)
{
break;
}
if (lastWriteSystemTime.Year >= fileYearsOld)
{
ok = false;
break;
}
break;
}
//
}
if (ok)
{
ok = this.CopyFile(handle, size, this.mTmpFile, ref creationTime, hr);
}
CloseHandle(handle);
if (ok)
{
var lPath = PrepareLongPath(path);
ok = MoveFileEx(this.mTmpFile, lPath, 1 | 8);
}
if (ok && enableHash)
{
this.WriteFileHash(path, hr);
}
if (ok)
{
//Thread.Sleep(1000);
this.SetProgressBarFinished(this.PrgbCurrentFile);
}
this.IncreaseProgressBarValue(this.PrgbTotal, size);
}
private bool CopyFile(
IntPtr srcFileHandle,
long size,
string dstPath,
ref FILETIME creationTime,
HashResults hr
)
{
var lDstPath = dstPath; // PrepareLongPath(dstPath);
var dstFileHandle = CreateFile(
lDstPath,
0x40000000,
FileShare.Read,
IntPtr.Zero,
FileMode.Create,
FileAttributes.Normal,
IntPtr.Zero
);
if (!IsValidFileHandle(dstFileHandle))
{
return(false);
}
var sha256 = (HashStream)null;
var crc32 = (HashStream)null;
var enableHash = (hr != null);
if (enableHash)
{
crc32 = new HashStream(new Force.Crc32.Crc32Algorithm());
sha256 = new HashStream(new SHA256Managed());
}
var offset = (long)0;
var buf = this.mBuffer;
var bufLen = (long)buf.Length;
while (this.mRunning)
{
var remain = size - offset;
if (remain <= 0)
{
break;
}
var nWantToRead = remain;
if (nWantToRead > bufLen)
{
nWantToRead = bufLen;
}
var nRead = (uint)0;
if (!ReadFile(srcFileHandle, buf, (uint)nWantToRead, out nRead, IntPtr.Zero))
{
break;
}
if (nRead != nWantToRead)
{
break;
}
var nWrite = (uint)0;
if (!WriteFile(dstFileHandle, buf, nRead, out nWrite, IntPtr.Zero))
{
break;
}
if (nWrite != nRead)
{
break;
}
if (enableHash)
{
crc32.Write(buf, 0, nRead);
sha256.Write(buf, 0, nRead);
}
offset += (long)nRead;
this.mBytesTransfered += (long)nRead;
this.IncreaseProgressBarValue(this.PrgbCurrentFile, nRead);
}
var fileTimeOK = SetFileTime(dstFileHandle, ref creationTime, IntPtr.Zero, IntPtr.Zero);
CloseHandle(dstFileHandle);
if (enableHash)
{
hr.crc32 = crc32.ComputeFinalHash();
crc32.Dispose();
hr.sha256 = sha256.ComputeFinalHash();
sha256.Dispose();
}
var result = (offset == size);
return(result);
}
