aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implemented 'checksum' verb with CRC32, CRC64, RIPEMD160, MD5,

Browse Source 
SHA1, SHA256, SHA384, SHA512
This commit is contained in:
Natalia Portillo
2014-07-03 18:35:19 +01:00
parent 4699522a40
commit 1e9cd0daec
9 changed files with 1633 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
DiscImageChef/Checksums/CRC32Context.cs Normal file
View File

@@ -0,0 +1,222 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : CRC32Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Implements a CRC32 algorithm.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Text;
using System.IO;
using System;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to calculate CRC32.
/// </summary>
public class CRC32Context
{
const UInt32 crc32Poly = 0xEDB88320;
const UInt32 crc32Seed = 0xFFFFFFFF;
UInt32[] table;
UInt32 hashInt;
/// <summary>
/// Initializes the CRC32 table and seed
/// </summary>
public void Init()
{
hashInt = crc32Seed;
table = new UInt32[256];
for (int i = 0; i < 256; i++)
{
UInt32 entry = (UInt32)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (entry >> 1) ^ crc32Poly;
else
entry = entry >> 1;
table[i] = entry;
}
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
for (int i = 0; i < len; i++)
hashInt = (hashInt >> 8) ^ table[data[i] ^ hashInt & 0xff];
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
hashInt ^= crc32Seed;
return BigEndianBitConverter.GetBytes(hashInt);
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
hashInt ^= crc32Seed;
StringBuilder crc32Output = new StringBuilder();
for (int i = 0; i < BigEndianBitConverter.GetBytes(hashInt).Length; i++)
{
crc32Output.Append(BigEndianBitConverter.GetBytes(hashInt)[i].ToString("x2"));
}
return crc32Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public static byte[] File(string filename)
{
byte[] hash;
File(filename, out hash);
return hash;
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public static string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
UInt32[] localTable;
UInt32 localhashInt;
localhashInt = crc32Seed;
localTable = new UInt32[256];
for (int i = 0; i < 256; i++)
{
UInt32 entry = (UInt32)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (entry >> 1) ^ crc32Poly;
else
entry = entry >> 1;
localTable[i] = entry;
}
for (int i = 0; i < fileStream.Length; i++)
localhashInt = (localhashInt >> 8) ^ localTable[fileStream.ReadByte() ^ localhashInt & 0xff];
hash = BitConverter.GetBytes(localhashInt);
StringBuilder crc32Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
crc32Output.Append(hash[i].ToString("x2"));
}
return crc32Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public static string Data(byte[] data, uint len, out byte[] hash)
{
UInt32[] localTable;
UInt32 localhashInt;
localhashInt = crc32Seed;
localTable = new UInt32[256];
for (int i = 0; i < 256; i++)
{
UInt32 entry = (UInt32)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (entry >> 1) ^ crc32Poly;
else
entry = entry >> 1;
localTable[i] = entry;
}
for (int i = 0; i < len; i++)
localhashInt = (localhashInt >> 8) ^ localTable[data[i] ^ localhashInt & 0xff];
hash = BitConverter.GetBytes(localhashInt);
StringBuilder crc32Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
crc32Output.Append(hash[i].ToString("x2"));
}
return crc32Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public static string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

221
DiscImageChef/Checksums/CRC64Context.cs Normal file
View File

@@ -0,0 +1,221 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : CRC64Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Checksums
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Implements a CRC64 algorithm.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Text;
using System.IO;
using System;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to calculate CRC64 (ECMA).
/// </summary>
public class CRC64Context
{
const UInt64 crc64Poly = 0xC96C5795D7870F42;
const UInt64 crc64Seed = 0xFFFFFFFFFFFFFFFF;
UInt64[] table;
UInt64 hashInt;
/// <summary>
/// Initializes the CRC64 table and seed
/// </summary>
public void Init()
{
hashInt = crc64Seed;
table = new UInt64[256];
for (int i = 0; i < 256; i++)
{
UInt64 entry = (UInt64)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (entry >> 1) ^ crc64Poly;
else
entry = entry >> 1;
table[i] = entry;
}
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
for (int i = 0; i < len; i++)
hashInt = (hashInt >> 8) ^ table[data[i] ^ hashInt & 0xff];
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
hashInt ^= crc64Seed;
return BigEndianBitConverter.GetBytes(hashInt);
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
hashInt ^= crc64Seed;
StringBuilder crc64Output = new StringBuilder();
for (int i = 0; i < BigEndianBitConverter.GetBytes(hashInt).Length; i++)
{
crc64Output.Append(BigEndianBitConverter.GetBytes(hashInt)[i].ToString("x2"));
}
return crc64Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public static byte[] File(string filename)
{
byte[] localHash;
File(filename, out localHash);
return localHash;
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public static string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
UInt64[] localTable;
UInt64 localhashInt;
localhashInt = crc64Seed;
localTable = new UInt64[256];
for (int i = 0; i < 256; i++)
{
UInt64 entry = (UInt64)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (entry >> 1) ^ crc64Poly;
else
entry = entry >> 1;
localTable[i] = entry;
}
for (int i = 0; i < fileStream.Length; i++)
localhashInt = (localhashInt >> 8) ^ localTable[(ulong)fileStream.ReadByte() ^ localhashInt & (ulong)0xff];
hash = BitConverter.GetBytes(localhashInt);
StringBuilder crc64Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
crc64Output.Append(hash[i].ToString("x2"));
}
return crc64Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public static string Data(byte[] data, uint len, out byte[] hash)
{
UInt64[] localTable;
UInt64 localhashInt;
localhashInt = crc64Seed;
localTable = new UInt64[256];
for (int i = 0; i < 256; i++)
{
UInt64 entry = (UInt64)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (entry >> 1) ^ crc64Poly;
else
entry = entry >> 1;
localTable[i] = entry;
}
for (int i = 0; i < len; i++)
localhashInt = (localhashInt >> 8) ^ localTable[data[i] ^ localhashInt & 0xff];
hash = BitConverter.GetBytes(localhashInt);
StringBuilder crc64Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
crc64Output.Append(hash[i].ToString("x2"));
}
return crc64Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public static string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

162
DiscImageChef/Checksums/MD5Context.cs Normal file
View File

@@ -0,0 +1,162 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : MD5Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Wraps up .NET MD5 implementation to a Init(), Update(), Final() context.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to .NET MD5.
/// </summary>
public class MD5Context
{
MD5 _md5Provider;
/// <summary>
/// Initializes the MD5 hash provider
/// </summary>
public void Init()
{
_md5Provider = MD5.Create();
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
_md5Provider.TransformBlock(data, 0, (int)len, data, 0);
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
_md5Provider.TransformFinalBlock(new byte[0], 0, 0);
return _md5Provider.Hash;
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
_md5Provider.TransformFinalBlock(new byte[0], 0, 0);
StringBuilder md5Output = new StringBuilder();
for (int i = 0; i < _md5Provider.Hash.Length; i++)
{
md5Output.Append(_md5Provider.Hash[i].ToString("x2"));
}
return md5Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public byte[] File(string filename)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
return _md5Provider.ComputeHash(fileStream);
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
hash = _md5Provider.ComputeHash(fileStream);
StringBuilder md5Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
md5Output.Append(hash[i].ToString("x2"));
}
return md5Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, uint len, out byte[] hash)
{
hash = _md5Provider.ComputeHash(data, 0, (int)len);
StringBuilder md5Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
md5Output.Append(hash[i].ToString("x2"));
}
return md5Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

162
DiscImageChef/Checksums/RIPEMD160Context.cs Normal file
View File

@@ -0,0 +1,162 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : RIPEMD160Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Wraps up .NET RIPEMD160 implementation to a Init(), Update(), Final() context.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to .NET RIPEMD160.
/// </summary>
public class RIPEMD160Context
{
RIPEMD160 _ripemd160Provider;
/// <summary>
/// Initializes the RIPEMD160 hash provider
/// </summary>
public void Init()
{
_ripemd160Provider = RIPEMD160.Create();
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
_ripemd160Provider.TransformBlock(data, 0, (int)len, data, 0);
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
_ripemd160Provider.TransformFinalBlock(new byte[0], 0, 0);
return _ripemd160Provider.Hash;
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
_ripemd160Provider.TransformFinalBlock(new byte[0], 0, 0);
StringBuilder ripemd160Output = new StringBuilder();
for (int i = 0; i < _ripemd160Provider.Hash.Length; i++)
{
ripemd160Output.Append(_ripemd160Provider.Hash[i].ToString("x2"));
}
return ripemd160Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public byte[] File(string filename)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
return _ripemd160Provider.ComputeHash(fileStream);
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
hash = _ripemd160Provider.ComputeHash(fileStream);
StringBuilder ripemd160Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
ripemd160Output.Append(hash[i].ToString("x2"));
}
return ripemd160Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, uint len, out byte[] hash)
{
hash = _ripemd160Provider.ComputeHash(data, 0, (int)len);
StringBuilder ripemd160Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
ripemd160Output.Append(hash[i].ToString("x2"));
}
return ripemd160Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

162
DiscImageChef/Checksums/SHA1Context.cs Normal file
View File

@@ -0,0 +1,162 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : SHA1Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Wraps up .NET SHA1 implementation to a Init(), Update(), Final() context.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to .NET SHA1.
/// </summary>
public class SHA1Context
{
SHA1 _sha1Provider;
/// <summary>
/// Initializes the SHA1 hash provider
/// </summary>
public void Init()
{
_sha1Provider = SHA1.Create();
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
_sha1Provider.TransformBlock(data, 0, (int)len, data, 0);
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
_sha1Provider.TransformFinalBlock(new byte[0], 0, 0);
return _sha1Provider.Hash;
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
_sha1Provider.TransformFinalBlock(new byte[0], 0, 0);
StringBuilder sha1Output = new StringBuilder();
for (int i = 0; i < _sha1Provider.Hash.Length; i++)
{
sha1Output.Append(_sha1Provider.Hash[i].ToString("x2"));
}
return sha1Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public byte[] File(string filename)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
return _sha1Provider.ComputeHash(fileStream);
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
hash = _sha1Provider.ComputeHash(fileStream);
StringBuilder sha1Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha1Output.Append(hash[i].ToString("x2"));
}
return sha1Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, uint len, out byte[] hash)
{
hash = _sha1Provider.ComputeHash(data, 0, (int)len);
StringBuilder sha1Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha1Output.Append(hash[i].ToString("x2"));
}
return sha1Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

162
DiscImageChef/Checksums/SHA256Context.cs Normal file
View File

@@ -0,0 +1,162 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : SHA256Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Wraps up .NET SHA256 implementation to a Init(), Update(), Final() context.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to .NET SHA256.
/// </summary>
public class SHA256Context
{
SHA256 _sha256Provider;
/// <summary>
/// Initializes the SHA256 hash provider
/// </summary>
public void Init()
{
_sha256Provider = SHA256.Create();
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
_sha256Provider.TransformBlock(data, 0, (int)len, data, 0);
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
_sha256Provider.TransformFinalBlock(new byte[0], 0, 0);
return _sha256Provider.Hash;
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
_sha256Provider.TransformFinalBlock(new byte[0], 0, 0);
StringBuilder sha256Output = new StringBuilder();
for (int i = 0; i < _sha256Provider.Hash.Length; i++)
{
sha256Output.Append(_sha256Provider.Hash[i].ToString("x2"));
}
return sha256Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public byte[] File(string filename)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
return _sha256Provider.ComputeHash(fileStream);
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
hash = _sha256Provider.ComputeHash(fileStream);
StringBuilder sha256Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha256Output.Append(hash[i].ToString("x2"));
}
return sha256Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, uint len, out byte[] hash)
{
hash = _sha256Provider.ComputeHash(data, 0, (int)len);
StringBuilder sha256Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha256Output.Append(hash[i].ToString("x2"));
}
return sha256Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

162
DiscImageChef/Checksums/SHA384Context.cs Normal file
View File

@@ -0,0 +1,162 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : SHA384Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Wraps up .NET SHA384 implementation to a Init(), Update(), Final() context.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to .NET SHA384.
/// </summary>
public class SHA384Context
{
SHA384 _sha384Provider;
/// <summary>
/// Initializes the SHA384 hash provider
/// </summary>
public void Init()
{
_sha384Provider = SHA384.Create();
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
_sha384Provider.TransformBlock(data, 0, (int)len, data, 0);
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
_sha384Provider.TransformFinalBlock(new byte[0], 0, 0);
return _sha384Provider.Hash;
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
_sha384Provider.TransformFinalBlock(new byte[0], 0, 0);
StringBuilder sha384Output = new StringBuilder();
for (int i = 0; i < _sha384Provider.Hash.Length; i++)
{
sha384Output.Append(_sha384Provider.Hash[i].ToString("x2"));
}
return sha384Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public byte[] File(string filename)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
return _sha384Provider.ComputeHash(fileStream);
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
hash = _sha384Provider.ComputeHash(fileStream);
StringBuilder sha384Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha384Output.Append(hash[i].ToString("x2"));
}
return sha384Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, uint len, out byte[] hash)
{
hash = _sha384Provider.ComputeHash(data, 0, (int)len);
StringBuilder sha384Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha384Output.Append(hash[i].ToString("x2"));
}
return sha384Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

162
DiscImageChef/Checksums/SHA512Context.cs Normal file
View File

@@ -0,0 +1,162 @@
/***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : SHA512Context.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Checksums.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Wraps up .NET SHA512 implementation to a Init(), Update(), Final() context.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Provides a UNIX similar API to .NET SHA512.
/// </summary>
public class SHA512Context
{
SHA512 _sha512Provider;
/// <summary>
/// Initializes the SHA512 hash provider
/// </summary>
public void Init()
{
_sha512Provider = SHA512.Create();
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of buffer to hash.</param>
public void Update(byte[] data, uint len)
{
_sha512Provider.TransformBlock(data, 0, (int)len, data, 0);
}
/// <summary>
/// Updates the hash with data.
/// </summary>
/// <param name="data">Data buffer.</param>
public void Update(byte[] data)
{
Update(data, (uint)data.Length);
}
/// <summary>
/// Returns a byte array of the hash value.
/// </summary>
public byte[] Final()
{
_sha512Provider.TransformFinalBlock(new byte[0], 0, 0);
return _sha512Provider.Hash;
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
_sha512Provider.TransformFinalBlock(new byte[0], 0, 0);
StringBuilder sha512Output = new StringBuilder();
for (int i = 0; i < _sha512Provider.Hash.Length; i++)
{
sha512Output.Append(_sha512Provider.Hash[i].ToString("x2"));
}
return sha512Output.ToString();
}
/// <summary>
/// Gets the hash of a file
/// </summary>
/// <param name="filename">File path.</param>
public byte[] File(string filename)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
return _sha512Provider.ComputeHash(fileStream);
}
/// <summary>
/// Gets the hash of a file in hexadecimal and as a byte array.
/// </summary>
/// <param name="filename">File path.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string File(string filename, out byte[] hash)
{
FileStream fileStream = new FileStream(filename, FileMode.Open);
hash = _sha512Provider.ComputeHash(fileStream);
StringBuilder sha512Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha512Output.Append(hash[i].ToString("x2"));
}
return sha512Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="len">Length of the data buffer to hash.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, uint len, out byte[] hash)
{
hash = _sha512Provider.ComputeHash(data, 0, (int)len);
StringBuilder sha512Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
sha512Output.Append(hash[i].ToString("x2"));
}
return sha512Output.ToString();
}
/// <summary>
/// Gets the hash of the specified data buffer.
/// </summary>
/// <param name="data">Data buffer.</param>
/// <param name="hash">Byte array of the hash value.</param>
public string Data(byte[] data, out byte[] hash)
{
return Data(data, (uint)data.Length, out hash);
}
}
}

221
DiscImageChef/Commands/Checksum.cs
View File

@@ -1,4 +1,44 @@
using System; /***************************************************************************
The Disc Image Chef
----------------------------------------------------------------------------
Filename : Checksum.cs
Version : 1.0
Author(s) : Natalia Portillo
Component : Verbs.
Revision : $Revision$
Last change by : $Author$
Date : $Date$
--[ Description ] ----------------------------------------------------------
Implements the 'checksum' verb.
--[ License ] --------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
Copyright (C) 2011-2014 Claunia.com
****************************************************************************/
//$Id$
using System;
using DiscImageChef.ImagePlugins;
using DiscImageChef.Checksums;
using System.Collections.Generic;
namespace DiscImageChef.Commands namespace DiscImageChef.Commands
{ {
@@ -14,11 +54,186 @@ namespace DiscImageChef.Commands
Console.WriteLine("--whole-disc={0}", options.WholeDisc); Console.WriteLine("--whole-disc={0}", options.WholeDisc);
Console.WriteLine("--input={0}", options.InputFile); Console.WriteLine("--input={0}", options.InputFile);
Console.WriteLine("--crc32={0}", options.DoCRC32); Console.WriteLine("--crc32={0}", options.DoCRC32);
Console.WriteLine("--crc64={0}", options.DoCRC64);
Console.WriteLine("--md5={0}", options.DoMD5); Console.WriteLine("--md5={0}", options.DoMD5);
Console.WriteLine("--ripemd160={0}", options.DoRIPEMD160);
Console.WriteLine("--sha1={0}", options.DoSHA1); Console.WriteLine("--sha1={0}", options.DoSHA1);
Console.WriteLine("--fuzzy={0}", options.DoFuzzy); Console.WriteLine("--sha256={0}", options.DoSHA256);
Console.WriteLine("--sha384={0}", options.DoSHA384);
Console.WriteLine("--sha512={0}", options.DoSHA512);
}
//throw new NotImplementedException("Checksumming not yet implemented.");
ImagePlugin inputFormat = ImageFormat.Detect(options.InputFile);
if (inputFormat == null)
{
Console.WriteLine("Unable to recognize image format, not checksumming");
return;
}
inputFormat.OpenImage(options.InputFile);
if (options.SeparatedTracks)
{
try
{
List<Track> inputTracks = inputFormat.GetTracks();
foreach (Track currentTrack in inputTracks)
{
CRC32Context crc32ctxTrack = new CRC32Context();
CRC64Context crc64ctxTrack = new CRC64Context();
MD5Context md5ctxTrack = new MD5Context();
RIPEMD160Context ripemd160ctxTrack = new RIPEMD160Context();
SHA1Context sha1ctxTrack = new SHA1Context();
SHA256Context sha256ctxTrack = new SHA256Context();
SHA384Context sha384ctxTrack = new SHA384Context();
SHA512Context sha512ctxTrack = new SHA512Context();
if (options.DoCRC32)
crc32ctxTrack.Init();
if (options.DoCRC64)
crc64ctxTrack.Init();
if (options.DoMD5)
md5ctxTrack.Init();
if (options.DoRIPEMD160)
ripemd160ctxTrack.Init();
if (options.DoSHA1)
sha1ctxTrack.Init();
if (options.DoSHA256)
sha256ctxTrack.Init();
if (options.DoSHA384)
sha384ctxTrack.Init();
if (options.DoSHA512)
sha512ctxTrack.Init();
ulong sectors = currentTrack.TrackEndSector - currentTrack.TrackStartSector + 1;
Console.WriteLine("Track {0} has {1} sectors", currentTrack.TrackSequence, sectors);
for (ulong i = currentTrack.TrackStartSector; i <= currentTrack.TrackEndSector; i++)
{
Console.Write("\rHashing sector {0} of track {1}", i + 1, currentTrack.TrackSequence);
byte[] sector = inputFormat.ReadSector(i, currentTrack.TrackSequence);
if (options.DoCRC32)
crc32ctxTrack.Update(sector);
if (options.DoCRC64)
crc64ctxTrack.Update(sector);
if (options.DoMD5)
md5ctxTrack.Update(sector);
if (options.DoRIPEMD160)
ripemd160ctxTrack.Update(sector);
if (options.DoSHA1)
sha1ctxTrack.Update(sector);
if (options.DoSHA256)
sha256ctxTrack.Update(sector);
if (options.DoSHA384)
sha384ctxTrack.Update(sector);
if (options.DoSHA512)
sha512ctxTrack.Update(sector);
}
Console.WriteLine();
if (options.DoCRC32)
Console.WriteLine("Track {0}'s CRC32: 0x{1}", currentTrack.TrackSequence, crc32ctxTrack.End());
if (options.DoCRC64)
Console.WriteLine("Track {0}'s CRC64 (ECMA): 0x{1}", currentTrack.TrackSequence, crc64ctxTrack.End());
if (options.DoMD5)
Console.WriteLine("Track {0}'s MD5: {1}", currentTrack.TrackSequence, md5ctxTrack.End());
if (options.DoRIPEMD160)
Console.WriteLine("Track {0}'s RIPEMD160: {1}", currentTrack.TrackSequence, ripemd160ctxTrack.End());
if (options.DoSHA1)
Console.WriteLine("Track {0}'s SHA1: {1}", currentTrack.TrackSequence, sha1ctxTrack.End());
if (options.DoSHA256)
Console.WriteLine("Track {0}'s SHA256: {1}", currentTrack.TrackSequence, sha256ctxTrack.End());
if (options.DoSHA384)
Console.WriteLine("Track {0}'s SHA384: {1}", currentTrack.TrackSequence, sha384ctxTrack.End());
if (options.DoSHA512)
Console.WriteLine("Track {0}'s SHA512: {1}", currentTrack.TrackSequence, sha512ctxTrack.End());
}
}
catch (Exception ex)
{
if (options.Debug)
Console.WriteLine("Could not get tracks because {0}", ex.Message);
else
Console.WriteLine("Unable to get separate tracks, not checksumming them");
}
}
if (options.WholeDisc)
{
CRC32Context crc32ctx = new CRC32Context();
CRC64Context crc64ctx = new CRC64Context();
MD5Context md5ctx = new MD5Context();
RIPEMD160Context ripemd160ctx = new RIPEMD160Context();
SHA1Context sha1ctx = new SHA1Context();
SHA256Context sha256ctx = new SHA256Context();
SHA384Context sha384ctx = new SHA384Context();
SHA512Context sha512ctx = new SHA512Context();
if (options.DoCRC32)
crc32ctx.Init();
if (options.DoCRC64)
crc64ctx.Init();
if (options.DoMD5)
md5ctx.Init();
if (options.DoRIPEMD160)
ripemd160ctx.Init();
if (options.DoSHA1)
sha1ctx.Init();
if (options.DoSHA256)
sha256ctx.Init();
if (options.DoSHA384)
sha384ctx.Init();
if (options.DoSHA512)
sha512ctx.Init();
ulong sectors = inputFormat.GetSectors();
Console.WriteLine("Sectors {0}", sectors);
for (ulong i = 0; i < sectors; i++)
{
Console.Write("\rHashing sector {0}", i + 1);
byte[] sector = inputFormat.ReadSector(i);
if (options.DoCRC32)
crc32ctx.Update(sector);
if (options.DoCRC64)
crc64ctx.Update(sector);
if (options.DoMD5)
md5ctx.Update(sector);
if (options.DoRIPEMD160)
ripemd160ctx.Update(sector);
if (options.DoSHA1)
sha1ctx.Update(sector);
if (options.DoSHA256)
sha256ctx.Update(sector);
if (options.DoSHA384)
sha384ctx.Update(sector);
if (options.DoSHA512)
sha512ctx.Update(sector);
}
Console.WriteLine();
if (options.DoCRC32)
Console.WriteLine("Disk's CRC32: 0x{0}", crc32ctx.End());
if (options.DoCRC64)
Console.WriteLine("Disk's CRC64 (ECMA): 0x{0}", crc64ctx.End());
if (options.DoMD5)
Console.WriteLine("Disk's MD5: {0}", md5ctx.End());
if (options.DoRIPEMD160)
Console.WriteLine("Disk's RIPEMD160: {0}", ripemd160ctx.End());
if (options.DoSHA1)
Console.WriteLine("Disk's SHA1: {0}", sha1ctx.End());
if (options.DoSHA256)
Console.WriteLine("Disk's SHA256: {0}", sha256ctx.End());
if (options.DoSHA384)
Console.WriteLine("Disk's SHA384: {0}", sha384ctx.End());
if (options.DoSHA512)
Console.WriteLine("Disk's SHA512: {0}", sha512ctx.End());
} }
throw new NotImplementedException("Checksumming not yet implemented.");
} }
} }
} }