public void CheckCorrectFile()
{
string result = Md5Context.File(Path.Combine(Consts.TestFilesRoot, "filters", "pcexchange", "FINDER.DAT"),
out _);
Assert.AreEqual(EXPECTED_FILE, result);
}
public bool?VerifyMediaImage()
{
byte[] calculated;
if (mapVersion >= 3)
{
Sha1Context sha1Ctx = new Sha1Context();
for (uint i = 0; i < totalHunks; i++)
{
sha1Ctx.Update(GetHunk(i));
}
calculated = sha1Ctx.Final();
}
else
{
Md5Context md5Ctx = new Md5Context();
for (uint i = 0; i < totalHunks; i++)
{
md5Ctx.Update(GetHunk(i));
}
calculated = md5Ctx.Final();
}
return(expectedChecksum.SequenceEqual(calculated));
}
public void Hashes()
{
Environment.CurrentDirectory = DataFolder;
Assert.Multiple(() =>
{
foreach (TapeImageTestExpected test in Tests)
{
string testFile = test.TestFile;
bool exists = File.Exists(testFile);
Assert.True(exists, $"{testFile} not found");
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
// It arrives here...
if (!exists)
{
continue;
}
var filtersList = new FiltersList();
IFilter filter = filtersList.GetFilter(testFile);
filter.Open(testFile);
var image = Activator.CreateInstance(_plugin.GetType()) as IMediaImage;
Assert.NotNull(image, $"Could not instantiate filesystem for {testFile}");
bool opened = image.Open(filter);
Assert.AreEqual(true, opened, $"Open: {testFile}");
if (!opened)
{
continue;
}
ulong doneSectors = 0;
var ctx = new Md5Context();
while (doneSectors < image.Info.Sectors)
{
byte[] sector;
if (image.Info.Sectors - doneSectors >= SECTORS_TO_READ)
{
sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
doneSectors += SECTORS_TO_READ;
}
else
{
sector = image.ReadSectors(doneSectors, (uint)(image.Info.Sectors - doneSectors));
doneSectors += image.Info.Sectors - doneSectors;
}
ctx.Update(sector);
}
Assert.AreEqual(test.MD5, ctx.End(), $"Hash: {testFile}");
}
});
}
internal Checksum()
{
_crc32Ctx = new Crc32Context();
_md5Ctx = new Md5Context();
_sha1Ctx = new Sha1Context();
_sha256Ctx = new Sha256Context();
_sha384Ctx = new Sha384Context();
_sha512Ctx = new Sha512Context();
_crc32Thread = new Thread(UpdateCrc32);
_md5Thread = new Thread(UpdateMd5);
_sha1Thread = new Thread(UpdateSha1);
_sha256Thread = new Thread(UpdateSha256);
_sha384Thread = new Thread(UpdateSha384);
_sha512Thread = new Thread(UpdateSha512);
_crc32Pkt = new Crc32Packet();
_md5Pkt = new Md5Packet();
_sha1Pkt = new Sha1Packet();
_sha256Pkt = new Sha256Packet();
_sha384Pkt = new Sha384Packet();
_sha512Pkt = new Sha512Packet();
_crc32Pkt.context = _crc32Ctx;
_md5Pkt.context = _md5Ctx;
_sha1Pkt.context = _sha1Ctx;
_sha256Pkt.context = _sha256Ctx;
_sha384Pkt.context = _sha384Ctx;
_sha512Pkt.context = _sha512Ctx;
}
string BuildFile(IReadOnlyFilesystem fs, string path, long length)
{
byte[] buffer = new byte[length];
fs.Read(path, 0, length, ref buffer);
return(Md5Context.Data(buffer, out _));
}
public void CheckCorrectFile()
{
string result = Md5Context.File(location, out _);
Assert.AreEqual(EXPECTED_FILE, result);
result = Md5Context.File(sidecar, out _);
Assert.AreEqual(EXPECTED_SIDECAR, result);
}
void TestFile(IReadOnlyFilesystem fs, string path, string md5, long length, string testFile)
{
byte[] buffer = new byte[length];
Errno ret = fs.Read(path, 0, length, ref buffer);
Assert.AreEqual(Errno.NoError, ret, $"Unexpected error {ret} when reading \"{path}\" in {testFile}");
string data = Md5Context.Data(buffer, out _);
Assert.AreEqual(md5, data, $"Got MD5 {data} for \"{path}\" in {testFile} but expected {md5}");
}
public void Md5RandomData()
{
byte[] data = new byte[1048576];
FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "random"), FileMode.Open,
FileAccess.Read);
fs.Read(data, 0, 1048576);
fs.Close();
fs.Dispose();
Md5Context.Data(data, out byte[] result);
Assert.AreEqual(ExpectedRandom, result);
}
public void Md5RandomData()
{
byte[] data = new byte[1048576];
var fs = new FileStream(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "random"),
FileMode.Open, FileAccess.Read);
fs.Read(data, 0, 1048576);
fs.Close();
fs.Dispose();
Md5Context.Data(data, out byte[] result);
Assert.AreEqual(_expectedRandom, result);
}
public void EmptyData()
{
byte[] data = new byte[1048576];
var fs = new FileStream(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "empty"), FileMode.Open,
FileAccess.Read);
fs.Read(data, 0, 1048576);
fs.Close();
fs.Dispose();
Md5Context.Data(data, out byte[] result);
result.Should().BeEquivalentTo(_expectedEmpty);
}
internal Checksum()
{
adler32ctx = new Adler32Context();
crc16ctx = new Crc16Context();
crc32ctx = new Crc32Context();
crc64ctx = new Crc64Context();
md5ctx = new Md5Context();
ripemd160ctx = new Ripemd160Context();
sha1ctx = new Sha1Context();
sha256ctx = new Sha256Context();
sha384ctx = new Sha384Context();
sha512ctx = new Sha512Context();
ssctx = new SpamSumContext();
adlerThread = new Thread(updateAdler);
crc16Thread = new Thread(updateCRC16);
crc32Thread = new Thread(updateCRC32);
crc64Thread = new Thread(updateCRC64);
md5Thread = new Thread(updateMD5);
ripemd160Thread = new Thread(updateRIPEMD160);
sha1Thread = new Thread(updateSHA1);
sha256Thread = new Thread(updateSHA256);
sha384Thread = new Thread(updateSHA384);
sha512Thread = new Thread(updateSHA512);
spamsumThread = new Thread(updateSpamSum);
adlerPkt = new adlerPacket();
crc16Pkt = new crc16Packet();
crc32Pkt = new crc32Packet();
crc64Pkt = new crc64Packet();
md5Pkt = new md5Packet();
ripemd160Pkt = new ripemd160Packet();
sha1Pkt = new sha1Packet();
sha256Pkt = new sha256Packet();
sha384Pkt = new sha384Packet();
sha512Pkt = new sha512Packet();
spamsumPkt = new spamsumPacket();
adlerPkt.context = adler32ctx;
crc16Pkt.context = crc16ctx;
crc32Pkt.context = crc32ctx;
crc64Pkt.context = crc64ctx;
md5Pkt.context = md5ctx;
ripemd160Pkt.context = ripemd160ctx;
sha1Pkt.context = sha1ctx;
sha256Pkt.context = sha256ctx;
sha384Pkt.context = sha384ctx;
sha512Pkt.context = sha512ctx;
spamsumPkt.context = ssctx;
}
public void Md5EmptyInstance()
{
byte[] data = new byte[1048576];
FileStream fs = new FileStream(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"), FileMode.Open,
FileAccess.Read);
fs.Read(data, 0, 1048576);
fs.Close();
fs.Dispose();
IChecksum ctx = new Md5Context();
ctx.Update(data);
byte[] result = ctx.Final();
Assert.AreEqual(ExpectedEmpty, result);
}
public void CheckContents()
{
IFilter filter = new DiscImageChef.Filters.GZip();
filter.Open(location);
Stream str = filter.GetDataForkStream();
byte[] data = new byte[1048576];
str.Read(data, 0, 1048576);
str.Close();
str.Dispose();
filter.Close();
Md5Context.Data(data, out byte[] result);
Assert.AreEqual(ExpectedContents, result);
}
public void EmptyInstance()
{
byte[] data = new byte[1048576];
var fs = new FileStream(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "empty"), FileMode.Open,
FileAccess.Read);
fs.Read(data, 0, 1048576);
fs.Close();
fs.Dispose();
IChecksum ctx = new Md5Context();
ctx.Update(data);
byte[] result = ctx.Final();
result.Should().BeEquivalentTo(_expectedEmpty);
}
public void Md5RandomInstance()
{
byte[] data = new byte[1048576];
var fs = new FileStream(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "random"),
FileMode.Open, FileAccess.Read);
fs.Read(data, 0, 1048576);
fs.Close();
fs.Dispose();
IChecksum ctx = new Md5Context();
ctx.Update(data);
byte[] result = ctx.Final();
Assert.AreEqual(_expectedRandom, result);
}
public void CheckResource()
{
IFilter filter = new MacBinary();
filter.Open(location);
Stream str = filter.GetResourceForkStream();
byte[] data = new byte[286];
str.Read(data, 0, 286);
str.Close();
str.Dispose();
filter.Close();
string result = Md5Context.Data(data, out _);
Assert.AreEqual(EXPECTED_RESOURCE, result);
}
public void CheckContents()
{
IFilter filter = new MacBinary();
filter.Open(location);
Stream str = filter.GetDataForkStream();
byte[] data = new byte[737280];
str.Read(data, 0, 737280);
str.Close();
str.Dispose();
filter.Close();
string result = Md5Context.Data(data, out _);
Assert.AreEqual(EXPECTED_CONTENTS, result);
}
void TestFileXattrs(IReadOnlyFilesystem fs, string path, Dictionary <string, string> xattrs, string testFile)
{
fs.ListXAttr(path, out List <string> contents);
if (xattrs.Count == 0 &&
contents.Count == 0)
{
return;
}
List <string> expectedNotFound = new List <string>();
foreach (KeyValuePair <string, string> xattr in xattrs)
{
byte[] buffer = new byte[0];
Errno ret = fs.GetXattr(path, xattr.Key, ref buffer);
if (ret == Errno.NoSuchExtendedAttribute ||
!contents.Contains(xattr.Key))
{
expectedNotFound.Add(xattr.Key);
continue;
}
contents.Remove(xattr.Key);
Assert.AreEqual(Errno.NoError, ret,
$"Unexpected error {ret} retrieving extended attributes for \"{path}\" in {testFile}");
string data = Md5Context.Data(buffer, out _);
Assert.AreEqual(xattr.Value, data,
$"Got MD5 {data} for {xattr.Key} of \"{path}\" in {testFile} but expected {xattr.Value}");
}
Assert.IsEmpty(expectedNotFound,
$"Could not find the following extended attributes of \"{path}\" in {testFile}: {string.Join(" ", expectedNotFound)}");
Assert.IsEmpty(contents,
$"Found the following unexpected extended attributes of \"{path}\" in {testFile}: {string.Join(" ", contents)}");
}
public void Test()
{
for (int i = 0; i < _testFiles.Length; i++)
{
string location = Path.Combine(Consts.TEST_FILES_ROOT, "Media image formats", "DiskCopy 4.2",
_testFiles[i]);
IFilter filter = new LZip();
filter.Open(location);
IMediaImage image = new DiscImages.DiskCopy42();
Assert.AreEqual(true, image.Open(filter), _testFiles[i]);
Assert.AreEqual(_sectors[i], image.Info.Sectors, _testFiles[i]);
Assert.AreEqual(_sectorSize[i], image.Info.SectorSize, _testFiles[i]);
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, _testFiles[i]);
// How many sectors to read at once
const uint sectorsToRead = 256;
ulong doneSectors = 0;
var ctx = new Md5Context();
while (doneSectors < image.Info.Sectors)
{
byte[] sector;
if (image.Info.Sectors - doneSectors >= sectorsToRead)
{
sector = image.ReadSectors(doneSectors, sectorsToRead);
doneSectors += sectorsToRead;
}
else
{
sector = image.ReadSectors(doneSectors, (uint)(image.Info.Sectors - doneSectors));
doneSectors += image.Info.Sectors - doneSectors;
}
ctx.Update(sector);
}
Assert.AreEqual(_md5S[i], ctx.End(), _testFiles[i]);
}
}
public void Test()
{
for (int i = 0; i < testfiles.Length; i++)
{
string location = Path.Combine(Consts.TestFilesRoot, "images", "2mg", testfiles[i]);
IFilter filter = new LZip();
filter.Open(location);
IMediaImage image = new DiscImages.Apple2Mg();
Assert.AreEqual(true, image.Open(filter), testfiles[i]);
Assert.AreEqual(sectors[i], image.Info.Sectors, testfiles[i]);
Assert.AreEqual(sectorsize[i], image.Info.SectorSize, testfiles[i]);
Assert.AreEqual(mediatypes[i], image.Info.MediaType, testfiles[i]);
// How many sectors to read at once
const uint SECTORS_TO_READ = 256;
ulong doneSectors = 0;
Md5Context ctx = new Md5Context();
while (doneSectors < image.Info.Sectors)
{
byte[] sector;
if (image.Info.Sectors - doneSectors >= SECTORS_TO_READ)
{
sector = image.ReadSectors(doneSectors, SECTORS_TO_READ);
doneSectors += SECTORS_TO_READ;
}
else
{
sector = image.ReadSectors(doneSectors, (uint)(image.Info.Sectors - doneSectors));
doneSectors += image.Info.Sectors - doneSectors;
}
ctx.Update(sector);
}
Assert.AreEqual(md5S[i], ctx.End(), testfiles[i]);
}
}
public void Test()
{
Environment.CurrentDirectory = Path.Combine(Consts.TEST_FILES_ROOT, "Media image formats", "CDRWin");
for (int i = 0; i < _testFiles.Length; i++)
{
IFilter filter = new ZZZNoFilter();
filter.Open(_testFiles[i]);
IOpticalMediaImage image = new CdrWin();
Assert.AreEqual(true, image.Open(filter), _testFiles[i]);
Assert.AreEqual(_sectors[i], image.Info.Sectors, _testFiles[i]);
Assert.AreEqual(_mediaTypes[i], image.Info.MediaType, _testFiles[i]);
Assert.AreEqual(_tracks[i], image.Tracks.Count, _testFiles[i]);
// How many sectors to read at once
const uint sectorsToRead = 256;
int trackNo = 0;
foreach (Track currentTrack in image.Tracks)
{
Assert.AreEqual(_trackSessions[i][trackNo], currentTrack.TrackSession, _testFiles[i]);
Assert.AreEqual(_trackStarts[i][trackNo], currentTrack.TrackStartSector, _testFiles[i]);
Assert.AreEqual(_trackEnds[i][trackNo], currentTrack.TrackEndSector, _testFiles[i]);
Assert.AreEqual(_trackPregaps[i][trackNo], currentTrack.TrackPregap, _testFiles[i]);
if (image.Info.ReadableSectorTags.Contains(SectorTagType.CdTrackFlags))
{
Assert.AreEqual(_trackFlags[i][trackNo],
image.ReadSectorTag(currentTrack.TrackSequence, SectorTagType.CdTrackFlags)[0],
_testFiles[i]);
}
trackNo++;
}
foreach (bool @long in new[]
{
false, true
})
{
var ctx = new Md5Context();
foreach (Track currentTrack in image.Tracks)
{
ulong sectors = (currentTrack.TrackEndSector - currentTrack.TrackStartSector) + 1;
ulong doneSectors = 0;
while (doneSectors < sectors)
{
byte[] sector;
if (sectors - doneSectors >= sectorsToRead)
{
sector =
@long ? image.ReadSectorsLong(doneSectors, sectorsToRead,
currentTrack.TrackSequence)
: image.ReadSectors(doneSectors, sectorsToRead, currentTrack.TrackSequence);
doneSectors += sectorsToRead;
}
else
{
sector = @long ? image.ReadSectorsLong(doneSectors, (uint)(sectors - doneSectors),
currentTrack.TrackSequence)
: image.ReadSectors(doneSectors, (uint)(sectors - doneSectors),
currentTrack.TrackSequence);
doneSectors += sectors - doneSectors;
}
ctx.Update(sector);
}
}
Assert.AreEqual(@long ? _longMd5S[i] : _md5S[i], ctx.End(), _testFiles[i]);
}
if (image.Info.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
{
var ctx = new Md5Context();
foreach (Track currentTrack in image.Tracks)
{
ulong sectors = (currentTrack.TrackEndSector - currentTrack.TrackStartSector) + 1;
ulong doneSectors = 0;
while (doneSectors < sectors)
{
byte[] sector;
if (sectors - doneSectors >= sectorsToRead)
{
sector = image.ReadSectorsTag(doneSectors, sectorsToRead, currentTrack.TrackSequence,
SectorTagType.CdSectorSubchannel);
doneSectors += sectorsToRead;
}
else
{
sector = image.ReadSectorsTag(doneSectors, (uint)(sectors - doneSectors),
currentTrack.TrackSequence,
SectorTagType.CdSectorSubchannel);
doneSectors += sectors - doneSectors;
}
ctx.Update(sector);
}
}
Assert.AreEqual(_subchannelMd5S[i], ctx.End(), _testFiles[i]);
}
}
}
public void CheckCorrectFile()
{
byte[] result = Md5Context.File(location);
Assert.AreEqual(ExpectedFile, result);
}
public void EmptyFile()
{
byte[] result = Md5Context.File(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "empty"));
result.Should().BeEquivalentTo(_expectedEmpty);
}
public bool?VerifyMediaImage()
{
if (_discImage.DiscHashes.Count == 0)
{
return(null);
}
// Read up to 1 MiB at a time for verification
const int verifySize = 1024 * 1024;
long readBytes;
byte[] verifyBytes;
IFilter[] filters = _discImage.Tracks.OrderBy(t => t.Sequence).Select(t => t.TrackFile.DataFilter).
Distinct().ToArray();
if (_discImage.DiscHashes.TryGetValue("sha1", out string sha1))
{
var ctx = new Sha1Context();
foreach (IFilter filter in filters)
{
Stream stream = filter.GetDataForkStream();
readBytes = 0;
verifyBytes = new byte[verifySize];
while (readBytes + verifySize < stream.Length)
{
stream.Read(verifyBytes, 0, verifyBytes.Length);
ctx.Update(verifyBytes);
readBytes += verifyBytes.LongLength;
}
verifyBytes = new byte[stream.Length - readBytes];
stream.Read(verifyBytes, 0, verifyBytes.Length);
ctx.Update(verifyBytes);
}
string verifySha1 = ctx.End();
AaruConsole.DebugWriteLine("CDRWin plugin", "Calculated SHA1: {0}", verifySha1);
AaruConsole.DebugWriteLine("CDRWin plugin", "Expected SHA1: {0}", sha1);
return(verifySha1 == sha1);
}
if (_discImage.DiscHashes.TryGetValue("md5", out string md5))
{
var ctx = new Md5Context();
foreach (IFilter filter in filters)
{
Stream stream = filter.GetDataForkStream();
readBytes = 0;
verifyBytes = new byte[verifySize];
while (readBytes + verifySize < stream.Length)
{
stream.Read(verifyBytes, 0, verifyBytes.Length);
ctx.Update(verifyBytes);
readBytes += verifyBytes.LongLength;
}
verifyBytes = new byte[stream.Length - readBytes];
stream.Read(verifyBytes, 0, verifyBytes.Length);
ctx.Update(verifyBytes);
}
string verifyMd5 = ctx.End();
AaruConsole.DebugWriteLine("CDRWin plugin", "Calculated MD5: {0}", verifyMd5);
AaruConsole.DebugWriteLine("CDRWin plugin", "Expected MD5: {0}", md5);
return(verifyMd5 == md5);
}
if (_discImage.DiscHashes.TryGetValue("crc32", out string crc32))
{
var ctx = new Crc32Context();
foreach (IFilter filter in filters)
{
Stream stream = filter.GetDataForkStream();
readBytes = 0;
verifyBytes = new byte[verifySize];
while (readBytes + verifySize < stream.Length)
{
stream.Read(verifyBytes, 0, verifyBytes.Length);
ctx.Update(verifyBytes);
readBytes += verifyBytes.LongLength;
}
verifyBytes = new byte[stream.Length - readBytes];
stream.Read(verifyBytes, 0, verifyBytes.Length);
ctx.Update(verifyBytes);
}
string verifyCrc = ctx.End();
AaruConsole.DebugWriteLine("CDRWin plugin", "Calculated CRC32: {0}", verifyCrc);
AaruConsole.DebugWriteLine("CDRWin plugin", "Expected CRC32: {0}", crc32);
return(verifyCrc == crc32);
}
foreach (string hash in _discImage.DiscHashes.Keys)
{
AaruConsole.DebugWriteLine("CDRWin plugin", "Found unsupported hash {0}", hash);
}
return(null);
}
public void Md5RandomFile()
{
byte[] result = Md5Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "random"));
Assert.AreEqual(ExpectedRandom, result);
}
public void Md5EmptyFile()
{
byte[] result = Md5Context.File(Path.Combine(Consts.TestFilesRoot, "checksums", "empty"));
Assert.AreEqual(ExpectedEmpty, result);
}
internal static List <ChecksumType> GetChecksums(byte[] data, EnableChecksum enabled = EnableChecksum.All)
{
IChecksum adler32CtxData = null;
IChecksum crc16CtxData = null;
IChecksum crc32CtxData = null;
IChecksum crc64CtxData = null;
IChecksum md5CtxData = null;
IChecksum sha1CtxData = null;
IChecksum sha256CtxData = null;
IChecksum sha384CtxData = null;
IChecksum sha512CtxData = null;
IChecksum ssctxData = null;
IChecksum f16CtxData = null;
IChecksum f32CtxData = null;
var adlerThreadData = new Thread(UpdateHash);
var crc16ThreadData = new Thread(UpdateHash);
var crc32ThreadData = new Thread(UpdateHash);
var crc64ThreadData = new Thread(UpdateHash);
var md5ThreadData = new Thread(UpdateHash);
var sha1ThreadData = new Thread(UpdateHash);
var sha256ThreadData = new Thread(UpdateHash);
var sha384ThreadData = new Thread(UpdateHash);
var sha512ThreadData = new Thread(UpdateHash);
var spamsumThreadData = new Thread(UpdateHash);
var f16ThreadData = new Thread(UpdateHash);
var f32ThreadData = new Thread(UpdateHash);
if (enabled.HasFlag(EnableChecksum.Adler32))
{
adler32CtxData = new Adler32Context();
var adlerPktData = new HashPacket
{
Context = adler32CtxData,
Data = data
};
adlerThreadData.Start(adlerPktData);
}
if (enabled.HasFlag(EnableChecksum.Crc16))
{
crc16CtxData = new CRC16IBMContext();
var crc16PktData = new HashPacket
{
Context = crc16CtxData,
Data = data
};
crc16ThreadData.Start(crc16PktData);
}
if (enabled.HasFlag(EnableChecksum.Crc32))
{
crc32CtxData = new Crc32Context();
var crc32PktData = new HashPacket
{
Context = crc32CtxData,
Data = data
};
crc32ThreadData.Start(crc32PktData);
}
if (enabled.HasFlag(EnableChecksum.Crc64))
{
crc64CtxData = new Crc64Context();
var crc64PktData = new HashPacket
{
Context = crc64CtxData,
Data = data
};
crc64ThreadData.Start(crc64PktData);
}
if (enabled.HasFlag(EnableChecksum.Md5))
{
md5CtxData = new Md5Context();
var md5PktData = new HashPacket
{
Context = md5CtxData,
Data = data
};
md5ThreadData.Start(md5PktData);
}
if (enabled.HasFlag(EnableChecksum.Sha1))
{
sha1CtxData = new Sha1Context();
var sha1PktData = new HashPacket
{
Context = sha1CtxData,
Data = data
};
sha1ThreadData.Start(sha1PktData);
}
if (enabled.HasFlag(EnableChecksum.Sha256))
{
sha256CtxData = new Sha256Context();
var sha256PktData = new HashPacket
{
Context = sha256CtxData,
Data = data
};
sha256ThreadData.Start(sha256PktData);
}
if (enabled.HasFlag(EnableChecksum.Sha384))
{
sha384CtxData = new Sha384Context();
var sha384PktData = new HashPacket
{
Context = sha384CtxData,
Data = data
};
sha384ThreadData.Start(sha384PktData);
}
if (enabled.HasFlag(EnableChecksum.Sha512))
{
sha512CtxData = new Sha512Context();
var sha512PktData = new HashPacket
{
Context = sha512CtxData,
Data = data
};
sha512ThreadData.Start(sha512PktData);
}
if (enabled.HasFlag(EnableChecksum.SpamSum))
{
ssctxData = new SpamSumContext();
var spamsumPktData = new HashPacket
{
Context = ssctxData,
Data = data
};
spamsumThreadData.Start(spamsumPktData);
}
if (enabled.HasFlag(EnableChecksum.Fletcher16))
{
f16CtxData = new Fletcher16Context();
var f16PktData = new HashPacket
{
Context = f16CtxData,
Data = data
};
f16ThreadData.Start(f16PktData);
}
if (enabled.HasFlag(EnableChecksum.Fletcher32))
{
f32CtxData = new Fletcher32Context();
var f32PktData = new HashPacket
{
Context = f32CtxData,
Data = data
};
f32ThreadData.Start(f32PktData);
}
while (adlerThreadData.IsAlive ||
crc16ThreadData.IsAlive ||
crc32ThreadData.IsAlive ||
crc64ThreadData.IsAlive ||
md5ThreadData.IsAlive ||
sha1ThreadData.IsAlive ||
sha256ThreadData.IsAlive ||
sha384ThreadData.IsAlive ||
sha512ThreadData.IsAlive ||
spamsumThreadData.IsAlive ||
f16ThreadData.IsAlive ||
f32ThreadData.IsAlive)
{
}
List <ChecksumType> dataChecksums = new List <ChecksumType>();
ChecksumType chk;
if (enabled.HasFlag(EnableChecksum.Adler32))
{
chk = new ChecksumType
{
type = ChecksumTypeType.adler32,
Value = adler32CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Crc16))
{
chk = new ChecksumType
{
type = ChecksumTypeType.crc16,
Value = crc16CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Crc32))
{
chk = new ChecksumType
{
type = ChecksumTypeType.crc32,
Value = crc32CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Crc64))
{
chk = new ChecksumType
{
type = ChecksumTypeType.crc64,
Value = crc64CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Md5))
{
chk = new ChecksumType
{
type = ChecksumTypeType.md5,
Value = md5CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Sha1))
{
chk = new ChecksumType
{
type = ChecksumTypeType.sha1,
Value = sha1CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Sha256))
{
chk = new ChecksumType
{
type = ChecksumTypeType.sha256,
Value = sha256CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Sha384))
{
chk = new ChecksumType
{
type = ChecksumTypeType.sha384,
Value = sha384CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Sha512))
{
chk = new ChecksumType
{
type = ChecksumTypeType.sha512,
Value = sha512CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.SpamSum))
{
chk = new ChecksumType
{
type = ChecksumTypeType.spamsum,
Value = ssctxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Fletcher16))
{
chk = new ChecksumType
{
type = ChecksumTypeType.fletcher16,
Value = f16CtxData.End()
};
dataChecksums.Add(chk);
}
if (enabled.HasFlag(EnableChecksum.Fletcher32))
{
chk = new ChecksumType
{
type = ChecksumTypeType.fletcher32,
Value = f32CtxData.End()
};
dataChecksums.Add(chk);
}
return(dataChecksums);
}
public void Test()
{
// How many sectors to read at once
const uint sectorsToRead = 256;
Environment.CurrentDirectory =
Path.Combine(Consts.TEST_FILES_ROOT, "Media image formats", "MagicISO", "Cuesheet");
IFilter[] filters = new IFilter[_testFiles.Length];
for (int i = 0; i < _testFiles.Length; i++)
{
filters[i] = new ZZZNoFilter();
filters[i].Open(_testFiles[i]);
}
IOpticalMediaImage[] images = new IOpticalMediaImage[_testFiles.Length];
for (int i = 0; i < _testFiles.Length; i++)
{
images[i] = new CdrWin();
Assert.AreEqual(true, images[i].Open(filters[i]), $"Open: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
Assert.AreEqual(_sectors[i], images[i].Info.Sectors, $"Sectors: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
Assert.AreEqual(_mediaTypes[i], images[i].Info.MediaType, $"Media type: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
Assert.AreEqual(_tracks[i], images[i].Tracks.Count, $"Tracks: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
images[i].Tracks.Select(t => t.TrackSession).Should().
BeEquivalentTo(_trackSessions[i], $"Track session: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
images[i].Tracks.Select(t => t.TrackStartSector).Should().
BeEquivalentTo(_trackStarts[i], $"Track start: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
images[i].Tracks.Select(t => t.TrackEndSector).Should().
BeEquivalentTo(_trackEnds[i], $"Track end: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
images[i].Tracks.Select(t => t.TrackPregap).Should().
BeEquivalentTo(_trackPregaps[i], $"Track pregap: {_testFiles[i]}");
}
for (int i = 0; i < _testFiles.Length; i++)
{
int trackNo = 0;
foreach (Track currentTrack in images[i].Tracks)
{
if (images[i].Info.ReadableSectorTags.Contains(SectorTagType.CdTrackFlags))
{
Assert.AreEqual(_trackFlags[i][trackNo],
images[i].ReadSectorTag(currentTrack.TrackSequence, SectorTagType.CdTrackFlags)
[0], $"Track flags: {_testFiles[i]}, track {currentTrack.TrackSequence}");
}
trackNo++;
}
}
foreach (bool @long in new[]
{
false, true
})
{
for (int i = 0; i < _testFiles.Length; i++)
{
var ctx = new Md5Context();
foreach (Track currentTrack in images[i].Tracks)
{
ulong sectors = currentTrack.TrackEndSector - currentTrack.TrackStartSector + 1;
ulong doneSectors = 0;
while (doneSectors < sectors)
{
byte[] sector;
if (sectors - doneSectors >= sectorsToRead)
{
sector = @long ? images[i].
ReadSectorsLong(doneSectors, sectorsToRead, currentTrack.TrackSequence)
: images[i].
ReadSectors(doneSectors, sectorsToRead, currentTrack.TrackSequence);
doneSectors += sectorsToRead;
}
else
{
sector = @long ? images[i].ReadSectorsLong(doneSectors, (uint)(sectors - doneSectors),
currentTrack.TrackSequence)
: images[i].ReadSectors(doneSectors, (uint)(sectors - doneSectors),
currentTrack.TrackSequence);
doneSectors += sectors - doneSectors;
}
ctx.Update(sector);
}
}
Assert.AreEqual(@long ? _longMd5S[i] : _md5S[i], ctx.End(),
$"{(@long ? "Long hash" : "Hash")}: {_testFiles[i]}");
}
}
for (int i = 0; i < _testFiles.Length; i++)
{
if (images[i].Info.ReadableSectorTags.Contains(SectorTagType.CdSectorSubchannel))
{
var ctx = new Md5Context();
foreach (Track currentTrack in images[i].Tracks)
{
ulong sectors = currentTrack.TrackEndSector - currentTrack.TrackStartSector + 1;
ulong doneSectors = 0;
while (doneSectors < sectors)
{
byte[] sector;
if (sectors - doneSectors >= sectorsToRead)
{
sector = images[i].ReadSectorsTag(doneSectors, sectorsToRead,
currentTrack.TrackSequence,
SectorTagType.CdSectorSubchannel);
doneSectors += sectorsToRead;
}
else
{
sector = images[i].ReadSectorsTag(doneSectors, (uint)(sectors - doneSectors),
currentTrack.TrackSequence,
SectorTagType.CdSectorSubchannel);
doneSectors += sectors - doneSectors;
}
ctx.Update(sector);
}
}
Assert.AreEqual(_subchannelMd5S[i], ctx.End(), $"Subchannel hash: {_testFiles[i]}");
}
}
}
public void Md5EmptyFile()
{
byte[] result = Md5Context.File(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "empty"));
Assert.AreEqual(_expectedEmpty, result);
}
public void Md5RandomFile()
{
byte[] result = Md5Context.File(Path.Combine(Consts.TEST_FILES_ROOT, "Checksum test files", "random"));
Assert.AreEqual(_expectedRandom, result);
}
