internal ContentTimeBasedObjectResult(T instance, DateTime created, byte[] checksum = null, Action <ContentTimeBasedOptions> setup = null) : base(instance, setup)
{
var options = setup.ConfigureOptions();
Created = created;
Checksum = new ChecksumResult(checksum);
Modified = options.Modified;
Validation = options.GetValidation(checksum);
}
static public ChecksumResult VerifyCheckSum(byte[] dataStream, UInt16 startPos, UInt16 endPos, byte checkSum)
{
ChecksumResult retValue = ChecksumResult.CHECKSUM_ERROR;
byte _checksum = 0x00;
for (int i = startPos; i <= endPos; i++)
{
_checksum ^= dataStream[i];
}
if (checkSum == _checksum)
{
retValue = ChecksumResult.CHECKSUM_OK;
}
return(retValue);
}
public MainForm(string path)
{
InitializeComponent();
crc32TextBox.Text =
md5TextBox.Text =
sha1TextBox.Text =
sha256TextBox.Text =
sha512TextBox.Text = "please wait";
pathLabel.Text = path;
var worker = new BackgroundWorker {
WorkerReportsProgress = true
};
worker.DoWork += delegate(object sender, DoWorkEventArgs e)
{
using (var stream = File.OpenRead(path))
{
using (var crc32 = CRC32.Create())
{
using (var md5 = MD5.Create())
{
using (var sha1 = SHA1.Create())
{
using (var sha256 = SHA256.Create())
{
using (var sha512 = SHA512.Create())
{
var totalLength = (double)stream.Length;
var lastPercentComplete = -1;
var buffer = new byte[4096];
int count;
for (long readBytes = 0; (count = stream.Read(buffer, 0, buffer.Length)) > 0; readBytes += count)
{
var crc32Offset = 0;
while (crc32Offset < count)
{
crc32Offset += crc32.TransformBlock(buffer, crc32Offset, count - crc32Offset, buffer, crc32Offset);
}
var md5Offset = 0;
while (md5Offset < count)
{
md5Offset += md5.TransformBlock(buffer, md5Offset, count - md5Offset, buffer, md5Offset);
}
var sha1Offset = 0;
while (sha1Offset < count)
{
sha1Offset += sha1.TransformBlock(buffer, sha1Offset, count - sha1Offset, buffer, sha1Offset);
}
var sha256Offset = 0;
while (sha256Offset < count)
{
sha256Offset += sha256.TransformBlock(buffer, sha256Offset, count - sha256Offset, buffer, sha256Offset);
}
var sha512Offset = 0;
while (sha512Offset < count)
{
sha512Offset += sha512.TransformBlock(buffer, sha512Offset, count - sha512Offset, buffer, sha512Offset);
}
var percentComplete = (int)((readBytes / totalLength) * 100);
if (percentComplete != lastPercentComplete)
{
worker.ReportProgress(percentComplete);
lastPercentComplete = percentComplete;
}
}
crc32.TransformFinalBlock(buffer, 0, 0);
md5.TransformFinalBlock(buffer, 0, 0);
sha1.TransformFinalBlock(buffer, 0, 0);
sha256.TransformFinalBlock(buffer, 0, 0);
sha512.TransformFinalBlock(buffer, 0, 0);
result = new ChecksumResult
{
CRC32 = $"{crc32.CRC32Hash:X4}",
MD5 = ToHexString(md5.Hash),
SHA1 = ToHexString(sha1.Hash),
SHA256 = ToHexString(sha256.Hash),
SHA512 = ToHexString(sha512.Hash)
};
}
}
}
}
}
}
};
worker.ProgressChanged += (sender, args) =>
{
crc32TextBox.Text =
md5TextBox.Text =
sha1TextBox.Text =
sha256TextBox.Text =
sha512TextBox.Text = $"{args.ProgressPercentage}%";
};
worker.RunWorkerCompleted += (sender, args) =>
{
crc32TextBox.Text = result.CRC32;
md5TextBox.Text = result.MD5;
sha1TextBox.Text = result.SHA1;
sha256TextBox.Text = result.SHA256;
sha512TextBox.Text = result.SHA512;
compareButton.Enabled = verifyPGPButton.Enabled = clipBoardButton.Enabled = true;
};
worker.RunWorkerAsync();
}
private void ReadCommand()
{
const int nrOfBytes = 64;
byte[] data;
logger.Debug("Reading flash content to file: " + m_fileName);
NotifyStatusChanged(this, new StatusEventArgs("Reading data from ECU..."));
using (MD5 md5Hash = MD5.Create())
{
if (File.Exists(m_fileName))
{
File.Delete(m_fileName);
}
FileStream fileStream = File.Create(m_fileName, 1024);
logger.Debug("File created");
SetFlashStatus(FlashStatus.Reading);
logger.Debug("Flash status is reading");
for (int i = 0; i < 512 * 1024 / nrOfBytes; i++)
{
lock (m_synchObject)
{
if (m_command == FlashCommand.StopCommand)
{
continue;
}
if (m_endThread)
{
return;
}
}
while (!m_kwpHandler.sendReadRequest((uint)(nrOfBytes * i), (uint)nrOfBytes))
{
m_nrOfRetries++;
}
while (!m_kwpHandler.sendRequestDataByOffset(out data))
{
m_nrOfRetries++;
}
fileStream.Write(data, 0, nrOfBytes);
md5Hash.TransformBlock(data, 0, nrOfBytes, data, 0);
m_nrOfBytesRead += nrOfBytes;
}
fileStream.Close();
logger.Debug("Closed file");
ChecksumResult checksumResult = ChecksumT7.VerifyChecksum(m_fileName, ChecksumT7.DO_NOT_AUTOCORRECT, ChecksumT7.DO_NOT_AUTOFIXFOOTER, m_ShouldUpdateChecksum);
if (checksumResult != ChecksumResult.Ok)
{
if (File.Exists(m_fileName))
{
File.Delete(m_fileName);
}
NotifyStatusChanged(this, new StatusEventArgs("Checksum check failed"));
}
else
{
Md5Tools.WriteMd5Hash(md5Hash, m_fileName);
}
}
m_kwpHandler.sendDataTransferExitRequest();
logger.Debug("Done reading");
}
static private ChecksumResult CalculateLayer2Checksum(string filename, int OffsetLayer2, bool autocorrect, ChecksumDelegate.ChecksumUpdate delegateShouldUpdate)
{
ChecksumResult result = ChecksumResult.Layer2Failed;
uint checksum0 = 0;
uint checksum1 = 0;
uint sum0 = 0;
uint matrix_dimension = 0;
uint partial_address = 0;
uint x = 0;
/*
* Get 0x100 byte buffer from CHPTR – CHPTR + 0xFF
* Because level 1 is in that area level1 must be correct first
* Prepare coded_buffer (0x100 buffer from chptr) with loop: coded_buffer(x) = (buffer (x) + 0xD6) xor 0x21
* (add 0xd6 to every byte of buffer, then xor it by 0x21)
* [ 1 indexed, not 0 indexed ]
* So, 0x101 byte buffer with first byte ignored (convention)
* */
byte[] coded_buffer = FileTools.readdatafromfile(filename, OffsetLayer2, 0x100);
for (int i = 0; i < coded_buffer.Length; i++)
{
byte b = coded_buffer[i];
b += 0xD6;
b ^= 0x21;
coded_buffer[i] = b;
}
byte[] complete_file = FileTools.readdatafromfile(filename, 0, 0x100000);
int index = 0;
bool chk_found = false;
while (index < 0x100 && !chk_found)
{
if ((coded_buffer[index] == 0xFB) && (coded_buffer[index + 6] == 0xFC) && (coded_buffer[index + 0x0C] == 0xFD))
{
sum0 = ((uint)coded_buffer[index + 1] * 0x01000000 + (uint)coded_buffer[index + 2] * 0x010000 + (uint)coded_buffer[index + 3] * 0x100 + (uint)coded_buffer[index + 4]);
matrix_dimension = (uint)coded_buffer[index + 7] * 0x01000000 + (uint)coded_buffer[index + 8] * 0x010000 + (uint)coded_buffer[index + 9] * 0x100 + (uint)coded_buffer[index + 10];
partial_address = (uint)coded_buffer[index + 0x0d] * 0x01000000 + (uint)coded_buffer[index + 0x0e] * 0x010000 + (uint)coded_buffer[index + 0x0F] * 0x100 + (uint)coded_buffer[index + 0x10];
if (matrix_dimension >= 0x020000)
{
checksum0 = 0;
x = partial_address;
while (x < (matrix_dimension - 4))
{
checksum0 = checksum0 + (uint)complete_file[x];
x++;
}
checksum0 = checksum0 + (uint)complete_file[matrix_dimension - 1];
checksum1 = 0;
x = partial_address;
while (x < (matrix_dimension - 4))
{
checksum1 = checksum1 + (uint)complete_file[x] * 0x01000000 + (uint)complete_file[x + 1] * 0x10000 + (uint)complete_file[x + 2] * 0x100 + (uint)complete_file[x + 3];
x = x + 4;
}
if ((checksum0 & 0xFFF00000) != (sum0 & 0xFFF00000))
{
checksum0 = checksum1;
}
if (checksum0 != sum0)
{
logger.Debug("Layer 2 checksum was invalid, should be updated!");
if (autocorrect)
{
result = UpdateLayer2(filename, OffsetLayer2, checksum0, index);
}
else
{
string filechecksum = sum0.ToString("X8");
string realchecksum = checksum0.ToString("X8");
if (delegateShouldUpdate("Checksum validation Layer 2", filechecksum, realchecksum))
{
result = UpdateLayer2(filename, OffsetLayer2, checksum0, index);
}
else
{
result = ChecksumResult.Layer2Failed;
}
}
}
else
{
result = ChecksumResult.Ok;
}
chk_found = true;
}
}
index++;
}
if (!chk_found)
{
logger.Debug("Layer 2 checksum could not be calculated [ file incompatible ]");
}
return(result);
}
static public ChecksumResult VerifyChecksum(string filename, bool autocorrect, bool autofixFooter, ChecksumDelegate.ChecksumUpdate delegateShouldUpdate)
{
csumArea = new csum_area_t[16];
for (int i = 0; i < csumArea.Length; i++)
{
csumArea[i] = new csum_area_t();
}
ChecksumResult result = ChecksumResult.Ok;
T7FileHeader t7InfoHeader = new T7FileHeader();
t7InfoHeader.init(filename, autofixFooter);
int sramOffset = t7InfoHeader.getSramOffset();
int fwLength = t7InfoHeader.getFWLength();
int calculatedFWChecksum = calculateFWChecksum(filename, sramOffset);
uint calculatedF2Checksum = calculateF2Checksum(filename, 0, fwLength);
int calculatedFBChecksum = calculateFBChecksum(filename, 0, fwLength);
int readF2checksum = t7InfoHeader.getChecksumF2();
int readFBchecksum = t7InfoHeader.getChecksumFB();
if (readF2checksum != 0)
{
if (t7InfoHeader.getChecksumF2() != (int)calculatedF2Checksum)
{
result = ChecksumResult.ChecksumF2Failed;
}
}
if (t7InfoHeader.getChecksumFB() != calculatedFBChecksum)
{
result = ChecksumResult.ChecksumFBFailed;
}
if (getFWChecksum(filename, sramOffset) != calculatedFWChecksum)
{
result = ChecksumResult.ChecksumFWFailed;
}
if (result != ChecksumResult.Ok)
{
logger.Debug("Checksum was invalid, should be updated!");
logger.Debug("calculatedF2Checksum = " + calculatedF2Checksum.ToString("X8") + " readF2checksum = " + readF2checksum.ToString("X8"));
logger.Debug("calculatedFBChecksum = " + calculatedFBChecksum.ToString("X8") + " readFBchecksum = " + readFBchecksum.ToString("X8"));
logger.Debug("calculatedFWChecksum = " + calculatedFWChecksum.ToString("X8") + " getFWChecksum = " + getFWChecksum(filename, sramOffset).ToString("X8"));
if (autocorrect)
{
result = updateChecksum(filename, t7InfoHeader, calculatedFWChecksum, calculatedF2Checksum, calculatedFBChecksum, sramOffset);
}
else
{
if (delegateShouldUpdate(null, null, null))
{
result = updateChecksum(filename, t7InfoHeader, calculatedFWChecksum, calculatedF2Checksum, calculatedFBChecksum, sramOffset);
}
}
}
return(result);
}
private ChecksumResult CalculateEDC15PChecksum(string filename, byte[] allBytes, bool verifyOnly, out ChecksumResultDetails result)
{
ChecksumResult res = new ChecksumResult();
// checksum for EDC15P is implemented
result = new ChecksumResultDetails();
result.CalculationResult = ChecksumResult.ChecksumFail; // default = failed
result.TypeResult = ChecksumType.VAG_EDC15P_V41;
if (allBytes.Length != 0x80000)
{
return(res);
}
if (allBytes[0x50008] == 'V' && allBytes[0x50009] == '4' && allBytes[0x5000A] == '.' && allBytes[0x5000B] == '1')
{
// checksum V4.1 rev.1
result.TypeResult = ChecksumType.VAG_EDC15P_V41;
}
else if (allBytes[0x58008] == 'V' && allBytes[0x58009] == '4' && allBytes[0x5800A] == '.' && allBytes[0x5800B] == '1')
{
// checksum V4.1 rev.2
result.TypeResult = ChecksumType.VAG_EDC15P_V41V2;
}
//allBytes = reverseEndian(allBytes);
EDC15P_checksum chks = new EDC15P_checksum();
if (result.TypeResult == ChecksumType.VAG_EDC15P_V41)
{
res = chks.tdi41_checksum_search(allBytes, (uint)allBytes.Length, false);
}
else
{
res = chks.tdi41v2_checksum_search(allBytes, (uint)allBytes.Length, false);
}
result.NumberChecksumsTotal = chks.ChecksumsFound;
result.NumberChecksumsFail = chks.ChecksumsIncorrect;
result.NumberChecksumsOk = chks.ChecksumsFound - chks.ChecksumsIncorrect;
if (res == ChecksumResult.ChecksumOK)
{
Console.WriteLine("Checksum V4.1 matched");
result.CalculationOk = true;
}
else if (res == ChecksumResult.ChecksumFail)
{
Console.WriteLine("UpdateChecksum: Checksum failed " + filename);
if (!verifyOnly)
{
File.WriteAllBytes(filename, allBytes);
result.CalculationOk = true;
Console.WriteLine("UpdateChecksum: Checksum fixed");
}
}
else if (res == ChecksumResult.ChecksumTypeError)
{
result.TypeResult = ChecksumType.VAG_EDC15P_V41_2002;
EDC15P_checksum chks2002 = new EDC15P_checksum();
allBytes = File.ReadAllBytes(filename);
//chks2002.DumpChecksumLocations("V41 2002", allBytes); // for debug info only
ChecksumResult res2002 = chks2002.tdi41_2002_checksum_search(allBytes, (uint)allBytes.Length, false);
result.NumberChecksumsTotal = chks2002.ChecksumsFound;
result.NumberChecksumsFail = chks2002.ChecksumsIncorrect;
result.NumberChecksumsOk = chks2002.ChecksumsFound - chks2002.ChecksumsIncorrect;
if (res2002 == ChecksumResult.ChecksumOK)
{
Console.WriteLine("Checksum 2002 matched " + filename);
result.CalculationOk = true;
}
else if (res2002 == ChecksumResult.ChecksumFail)
{
Console.WriteLine("UpdateChecksum: Checksum 2002 failed " + filename);
if (!verifyOnly)
{
File.WriteAllBytes(filename, allBytes);
result.CalculationOk = true;
Console.WriteLine("UpdateChecksum: Checksum fixed");
}
}
else if (res2002 == ChecksumResult.ChecksumTypeError)
{
// unknown checksum type
result.CalculationOk = false;
result.CalculationResult = ChecksumResult.ChecksumTypeError;
result.TypeResult = ChecksumType.Unknown;
}
}
return(res);
}
public ChecksumResultDetails UpdateChecksum(string filename, bool verifyOnly)
{
byte[] allBytes;
ChecksumResult res = new ChecksumResult();;
ChecksumResultDetails result = new ChecksumResultDetails();
EDCFileType fileType = DetermineFileType(filename, false);
switch (fileType)
{
case EDCFileType.EDC15P:
case EDCFileType.EDC15P6:
allBytes = File.ReadAllBytes(filename);
res = CalculateEDC15PChecksum(filename, allBytes, verifyOnly, out result);
break;
case EDCFileType.EDC15V:
// EDC15VM+ is similar to EDC15P
allBytes = File.ReadAllBytes(filename);
res = CalculateEDC15VMChecksum(filename, allBytes, verifyOnly, out result);
break;
case EDCFileType.EDC15C:
//TODO: Implement EDC15C checksum routine here
break;
case EDCFileType.EDC15M:
//TODO: Implement EDC15M checksum routine here
break;
case EDCFileType.EDC16:
//TODO: Implement EDC16x checksum routine here
break;
case EDCFileType.EDC17:
//TODO: Implement EDC17x checksum routine here
break;
case EDCFileType.MSA15:
case EDCFileType.MSA12:
case EDCFileType.MSA11:
//TODO: Implement MSA15 checksum routine here
// this should be Bosch TDI V3.1 (Version 2.04)
/* result.TypeResult = ChecksumType.VAG_EDC15P_V41;
* allBytes = File.ReadAllBytes(filename);
* //allBytes = reverseEndian(allBytes);
* MSA15_checksum msa15chks = new MSA15_checksum();
*
* res = msa15chks.tdi41_checksum_search(allBytes, (uint)allBytes.Length, false);
* result.NumberChecksumsTotal = msa15chks.ChecksumsFound;
* result.NumberChecksumsFail = msa15chks.ChecksumsIncorrect;
* result.NumberChecksumsOk = msa15chks.ChecksumsFound - msa15chks.ChecksumsIncorrect;
* if (res == ChecksumResult.ChecksumOK)
* {
* //Console.WriteLine("Checksum matched");
* result.CalculationOk = true;
* }
* else if (res == ChecksumResult.ChecksumFail)
* {
* Console.WriteLine("UpdateChecksum: Checksum failed " + filename);
* if (!verifyOnly)
* {
* File.WriteAllBytes(filename, allBytes);
* result.CalculationOk = true;
* Console.WriteLine("UpdateChecksum: Checksum fixed");
* }
*
* }*/
break;
case EDCFileType.MSA6:
//TODO: Implement MSA6 checksum routine here
break;
}
if (result.CalculationOk)
{
result.CalculationResult = ChecksumResult.ChecksumOK;
}
return(result);
}
private ChecksumResult CalculateEDC15VMChecksum(string filename, byte[] allBytes, bool verifyOnly, out ChecksumResultDetails result)
{
ChecksumResult res = new ChecksumResult();
result = new ChecksumResultDetails();
result.CalculationResult = ChecksumResult.ChecksumFail; // default = failed
result.TypeResult = ChecksumType.VAG_EDC15VM_V41;
if (/*allBytes.Length != 0x40000 && */allBytes.Length != 0x80000 && allBytes.Length != 0x100000) return res;
if (allBytes.Length >= 0x80000)
{
if (allBytes[0x50008] == 'V' && allBytes[0x50009] == '4' && allBytes[0x5000A] == '.' && allBytes[0x5000B] == '1')
{
// checksum V4.1 rev.1
result.TypeResult = ChecksumType.VAG_EDC15VM_V41;
}
else if (allBytes[0x58008] == 'V' && allBytes[0x58009] == '4' && allBytes[0x5800A] == '.' && allBytes[0x5800B] == '1')
{
// checksum V4.1 rev.2
result.TypeResult = ChecksumType.VAG_EDC15VM_V41V2;
}
}
//allBytes = reverseEndian(allBytes);
EDC15VM_checksum chks = new EDC15VM_checksum();
if (result.TypeResult == ChecksumType.VAG_EDC15VM_V41)
{
res = chks.tdi41_checksum_search(allBytes, (uint)allBytes.Length, false);
}
else
{
res = chks.tdi41v2_checksum_search(allBytes, (uint)allBytes.Length, false);
}
result.NumberChecksumsTotal = chks.ChecksumsFound;
result.NumberChecksumsFail = chks.ChecksumsIncorrect;
result.NumberChecksumsOk = chks.ChecksumsFound - chks.ChecksumsIncorrect;
if (res == ChecksumResult.ChecksumOK)
{
Console.WriteLine("Checksum V4.1 matched");
result.CalculationOk = true;
}
else if (res == ChecksumResult.ChecksumFail)
{
Console.WriteLine("UpdateChecksum: Checksum failed " + filename);
if (!verifyOnly)
{
File.WriteAllBytes(filename, allBytes);
result.CalculationOk = true;
Console.WriteLine("UpdateChecksum: Checksum fixed");
}
}
else if (res == ChecksumResult.ChecksumTypeError)
{
result.TypeResult = ChecksumType.VAG_EDC15VM_V41_2002;
EDC15VM_checksum chks2002 = new EDC15VM_checksum();
allBytes = File.ReadAllBytes(filename);
ChecksumResult res2002 = chks2002.tdi41_2002_checksum_search(allBytes, (uint)allBytes.Length, false);
result.NumberChecksumsTotal = chks2002.ChecksumsFound;
result.NumberChecksumsFail = chks2002.ChecksumsIncorrect;
result.NumberChecksumsOk = chks2002.ChecksumsFound - chks2002.ChecksumsIncorrect;
if (res2002 == ChecksumResult.ChecksumOK)
{
Console.WriteLine("Checksum 2002 matched " + filename);
result.CalculationOk = true;
}
else if (res2002 == ChecksumResult.ChecksumFail)
{
Console.WriteLine("UpdateChecksum: Checksum 2002 failed " + filename);
if (!verifyOnly)
{
File.WriteAllBytes(filename, allBytes);
result.CalculationOk = true;
Console.WriteLine("UpdateChecksum: Checksum fixed");
}
}
else if (res2002 == ChecksumResult.ChecksumTypeError)
{
// unknown checksum type
result.CalculationOk = false;
result.CalculationResult = ChecksumResult.ChecksumTypeError;
result.TypeResult = ChecksumType.Unknown;
}
}
return res;
}
public ChecksumResultDetails UpdateChecksum(string filename, bool verifyOnly)
{
byte[] allBytes;
ChecksumResult res = new ChecksumResult(); ;
ChecksumResultDetails result = new ChecksumResultDetails();
EDCFileType fileType = DetermineFileType(filename, false);
switch (fileType)
{
case EDCFileType.EDC15P:
case EDCFileType.EDC15P6:
allBytes = File.ReadAllBytes(filename);
res = CalculateEDC15PChecksum(filename, allBytes, verifyOnly, out result);
break;
case EDCFileType.EDC15V:
// EDC15VM+ is similar to EDC15P
allBytes = File.ReadAllBytes(filename);
res = CalculateEDC15VMChecksum(filename, allBytes, verifyOnly, out result);
break;
case EDCFileType.EDC15C:
//TODO: Implement EDC15C checksum routine here
break;
case EDCFileType.EDC15M:
//TODO: Implement EDC15M checksum routine here
break;
case EDCFileType.EDC16:
//TODO: Implement EDC16x checksum routine here
break;
case EDCFileType.EDC17:
//TODO: Implement EDC17x checksum routine here
break;
case EDCFileType.MSA15:
case EDCFileType.MSA12:
case EDCFileType.MSA11:
//TODO: Implement MSA15 checksum routine here
// this should be Bosch TDI V3.1 (Version 2.04)
/* result.TypeResult = ChecksumType.VAG_EDC15P_V41;
allBytes = File.ReadAllBytes(filename);
//allBytes = reverseEndian(allBytes);
MSA15_checksum msa15chks = new MSA15_checksum();
res = msa15chks.tdi41_checksum_search(allBytes, (uint)allBytes.Length, false);
result.NumberChecksumsTotal = msa15chks.ChecksumsFound;
result.NumberChecksumsFail = msa15chks.ChecksumsIncorrect;
result.NumberChecksumsOk = msa15chks.ChecksumsFound - msa15chks.ChecksumsIncorrect;
if (res == ChecksumResult.ChecksumOK)
{
//Console.WriteLine("Checksum matched");
result.CalculationOk = true;
}
else if (res == ChecksumResult.ChecksumFail)
{
Console.WriteLine("UpdateChecksum: Checksum failed " + filename);
if (!verifyOnly)
{
File.WriteAllBytes(filename, allBytes);
result.CalculationOk = true;
Console.WriteLine("UpdateChecksum: Checksum fixed");
}
}*/
break;
case EDCFileType.MSA6:
//TODO: Implement MSA6 checksum routine here
break;
}
if (result.CalculationOk) result.CalculationResult = ChecksumResult.ChecksumOK;
return result;
}
internal ContentBasedObjectResult(T instance, byte[] checksum, Action <ContentBasedOptions> setup = null) : base(instance, setup)
{
Checksum = new ChecksumResult(checksum);
Validation = Options.GetValidation(checksum);
}
