aaru-dps/Aaru.Server
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Server.git synced 2025-12-16 19:24:27 +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);
}
}
}