claunia/SharpHash
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Added CRC16, CRC32, CRC64, MD5, RIPEMD160, SHA1, SHA256, SHA384 and SHA512 algorithms

Browse Source
This commit is contained in:
Natalia Portillo
2015-02-02 12:48:20 +00:00
parent 6d8fbf6d63
commit 1b0acde7c5
11 changed files with 2192 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

632
SharpHash/BigEndianBitConverter.cs Normal file
View File

@@ -0,0 +1,632 @@
//
// BigEndianBitConverter.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System;
using System.Linq;
namespace SharpHash
{
/// <summary>
/// Converts base data types to an array of bytes, and an array of bytes to base
/// data types.
/// All info taken from the meta data of System.BitConverter. This implementation
/// allows for Endianness consideration.
///</summary>
public static class BigEndianBitConverter
{
/// <summary>
/// Indicates the byte order ("endianess") in which data is stored in this computer
/// architecture.
///</summary>
public static bool IsLittleEndian { get; set; }
// should default to false, which is what we want for Empire
/// <summary>
/// Converts the specified double-precision floating point number to a 64-bit
/// signed integer.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// A 64-bit signed integer whose value is equivalent to value.
///</summary>
public static long DoubleToInt64Bits(double value)
{
throw new NotImplementedException();
}
///
/// <summary>
/// Returns the specified Boolean value as an array of bytes.
///
/// Parameters:
/// value:
/// A Boolean value.
///
/// Returns:
/// An array of bytes with length 1.
///</summary>
public static byte[] GetBytes(bool value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified Unicode character value as an array of bytes.
///
/// Parameters:
/// value:
/// A character to convert.
///
/// Returns:
/// An array of bytes with length 2.
///</summary>
public static byte[] GetBytes(char value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified double-precision floating point value as an array of
/// bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 8.
///</summary>
public static byte[] GetBytes(double value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified single-precision floating point value as an array of
/// bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 4.
///</summary>
public static byte[] GetBytes(float value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified 32-bit signed integer value as an array of bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 4.
///</summary>
public static byte[] GetBytes(int value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified 64-bit signed integer value as an array of bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 8.
///</summary>
public static byte[] GetBytes(long value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified 16-bit signed integer value as an array of bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 2.
///</summary>
public static byte[] GetBytes(short value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified 32-bit unsigned integer value as an array of bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 4.
///</summary>
//[CLSCompliant(false)]
public static byte[] GetBytes(uint value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified 64-bit unsigned integer value as an array of bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 8.
///</summary>
//[CLSCompliant(false)]
public static byte[] GetBytes(ulong value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Returns the specified 16-bit unsigned integer value as an array of bytes.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// An array of bytes with length 2.
///</summary>
public static byte[] GetBytes(ushort value)
{
return !IsLittleEndian ? BitConverter.GetBytes(value) : BitConverter.GetBytes(value).Reverse().ToArray();
}
///
/// <summary>
/// Converts the specified 64-bit signed integer to a double-precision floating
/// point number.
///
/// Parameters:
/// value:
/// The number to convert.
///
/// Returns:
/// A double-precision floating point number whose value is equivalent to value.
///</summary>
public static double Int64BitsToDouble(long value)
{
throw new NotImplementedException();
}
///
/// <summary>
/// Returns a Boolean value converted from one byte at a specified position in
/// a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// true if the byte at startIndex in value is nonzero; otherwise, false.
///
/// Exceptions:
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static bool ToBoolean(byte[] value, int startIndex)
{
throw new NotImplementedException();
}
///
/// <summary>
/// Returns a Unicode character converted from two bytes at a specified position
/// in a byte array.
///
/// Parameters:
/// value:
/// An array.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A character formed by two bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex equals the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static char ToChar(byte[] value, int startIndex)
{
throw new NotImplementedException();
}
///
/// <summary>
/// Returns a double-precision floating point number converted from eight bytes
/// at a specified position in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A double precision floating point number formed by eight bytes beginning
/// at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex is greater than or equal to the length of value minus 7, and is
/// less than or equal to the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static double ToDouble(byte[] value, int startIndex)
{
throw new NotImplementedException();
}
///
/// <summary>
/// Returns a 16-bit signed integer converted from two bytes at a specified position
/// in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A 16-bit signed integer formed by two bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex equals the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static short ToInt16(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToInt16(value, startIndex) : BitConverter.ToInt16(value.Reverse().ToArray(), value.Length - sizeof(Int16) - startIndex);
}
///
/// <summary>
/// Returns a 32-bit signed integer converted from four bytes at a specified
/// position in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A 32-bit signed integer formed by four bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex is greater than or equal to the length of value minus 3, and is
/// less than or equal to the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static int ToInt32(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToInt32(value, startIndex) : BitConverter.ToInt32(value.Reverse().ToArray(), value.Length - sizeof(Int32) - startIndex);
}
///
/// <summary>
/// Returns a 64-bit signed integer converted from eight bytes at a specified
/// position in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A 64-bit signed integer formed by eight bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex is greater than or equal to the length of value minus 7, and is
/// less than or equal to the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static long ToInt64(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToInt64(value, startIndex) : BitConverter.ToInt64(value.Reverse().ToArray(), value.Length - sizeof(Int64) - startIndex);
}
///
/// <summary>
/// Returns a single-precision floating point number converted from four bytes
/// at a specified position in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A single-precision floating point number formed by four bytes beginning at
/// startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex is greater than or equal to the length of value minus 3, and is
/// less than or equal to the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static float ToSingle(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToSingle(value, startIndex) : BitConverter.ToSingle(value.Reverse().ToArray(), value.Length - sizeof(Single) - startIndex);
}
///
/// <summary>
/// Converts the numeric value of each element of a specified array of bytes
/// to its equivalent hexadecimal string representation.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// Returns:
/// A System.String of hexadecimal pairs separated by hyphens, where each pair
/// represents the corresponding element in value; for example, "7F-2C-4A".
///
/// Exceptions:
/// System.ArgumentNullException:
/// value is null.
///</summary>
public static string ToString(byte[] value)
{
return !IsLittleEndian ? BitConverter.ToString(value) : BitConverter.ToString(value.Reverse().ToArray());
}
///
/// <summary>
/// Converts the numeric value of each element of a specified subarray of bytes
/// to its equivalent hexadecimal string representation.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A System.String of hexadecimal pairs separated by hyphens, where each pair
/// represents the corresponding element in a subarray of value; for example,
/// "7F-2C-4A".
///
/// Exceptions:
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static string ToString(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToString(value, startIndex) : BitConverter.ToString(value.Reverse().ToArray(), startIndex);
}
///
/// <summary>
/// Converts the numeric value of each element of a specified subarray of bytes
/// to its equivalent hexadecimal string representation.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// length:
/// The number of array elements in value to convert.
///
/// Returns:
/// A System.String of hexadecimal pairs separated by hyphens, where each pair
/// represents the corresponding element in a subarray of value; for example,
/// "7F-2C-4A".
///
/// Exceptions:
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex or length is less than zero. -or- startIndex is greater than
/// zero and is greater than or equal to the length of value.
///
/// System.ArgumentException:
/// The combination of startIndex and length does not specify a position within
/// value; that is, the startIndex parameter is greater than the length of value
/// minus the length parameter.
///</summary>
public static string ToString(byte[] value, int startIndex, int length)
{
return !IsLittleEndian ? BitConverter.ToString(value, startIndex, length) : BitConverter.ToString(value.Reverse().ToArray(), startIndex, length);
}
///
/// <summary>
/// Returns a 16-bit unsigned integer converted from two bytes at a specified
/// position in a byte array.
///
/// Parameters:
/// value:
/// The array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A 16-bit unsigned integer formed by two bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex equals the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static ushort ToUInt16(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToUInt16(value, startIndex) : BitConverter.ToUInt16(value.Reverse().ToArray(), value.Length - sizeof(UInt16) - startIndex);
}
///
/// <summary>
/// Returns a 32-bit unsigned integer converted from four bytes at a specified
/// position in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A 32-bit unsigned integer formed by four bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex is greater than or equal to the length of value minus 3, and is
/// less than or equal to the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static uint ToUInt32(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToUInt32(value, startIndex) : BitConverter.ToUInt32(value.Reverse().ToArray(), value.Length - sizeof(UInt32) - startIndex);
}
///
/// <summary>
/// Returns a 64-bit unsigned integer converted from eight bytes at a specified
/// position in a byte array.
///
/// Parameters:
/// value:
/// An array of bytes.
///
/// startIndex:
/// The starting position within value.
///
/// Returns:
/// A 64-bit unsigned integer formed by the eight bytes beginning at startIndex.
///
/// Exceptions:
/// System.ArgumentException:
/// startIndex is greater than or equal to the length of value minus 7, and is
/// less than or equal to the length of value minus 1.
///
/// System.ArgumentNullException:
/// value is null.
///
/// System.ArgumentOutOfRangeException:
/// startIndex is less than zero or greater than the length of value minus 1.
///</summary>
public static ulong ToUInt64(byte[] value, int startIndex)
{
return !IsLittleEndian ? BitConverter.ToUInt64(value, startIndex) : BitConverter.ToUInt64(value.Reverse().ToArray(), value.Length - sizeof(UInt64) - startIndex);
}
}
}

219
SharpHash/Checksums/CRC16Context.cs Normal file
View File

@@ -0,0 +1,219 @@
//
// CRC16Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Text;
using System.IO;
using System;
namespace SharpHash.Checksums
{
/// <summary>
/// Provides a UNIX similar API to calculate CRC16.
/// </summary>
public class CRC16Context
{
const UInt16 crc16Poly = 0x8408;
const UInt16 crc16Seed = 0xFFFF;
UInt16[] table;
UInt16 hashInt;
/// <summary>
/// Initializes the CRC16 table and seed
/// </summary>
public void Init()
{
hashInt = crc16Seed;
table = new UInt16[256];
for (int i = 0; i < 256; i++)
{
UInt16 entry = (UInt16)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (ushort)((entry >> 1) ^ crc16Poly);
else
entry = (ushort)(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 = (ushort)((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 ^= crc16Seed;
return BigEndianBitConverter.GetBytes(hashInt);
}
/// <summary>
/// Returns a hexadecimal representation of the hash value.
/// </summary>
public string End()
{
hashInt ^= crc16Seed;
StringBuilder crc16Output = new StringBuilder();
for (int i = 0; i < BigEndianBitConverter.GetBytes(hashInt).Length; i++)
{
crc16Output.Append(BigEndianBitConverter.GetBytes(hashInt)[i].ToString("x2"));
}
return crc16Output.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);
UInt16[] localTable;
UInt16 localhashInt;
localhashInt = crc16Seed;
localTable = new UInt16[256];
for (int i = 0; i < 256; i++)
{
UInt16 entry = (UInt16)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (ushort)((entry >> 1) ^ crc16Poly);
else
entry = (ushort)(entry >> 1);
localTable[i] = entry;
}
for (int i = 0; i < fileStream.Length; i++)
localhashInt = (ushort)((localhashInt >> 8) ^ localTable[fileStream.ReadByte() ^ localhashInt & 0xff]);
hash = BitConverter.GetBytes(localhashInt);
StringBuilder crc16Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
crc16Output.Append(hash[i].ToString("x2"));
}
return crc16Output.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)
{
return Data(data, len, out hash, crc16Poly, crc16Seed);
}
/// <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>
/// <param name="polynomial">CRC polynomial</param>
/// <param name="seed">CRC seed</param>
public static string Data(byte[] data, uint len, out byte[] hash, UInt16 polynomial, UInt16 seed)
{
UInt16[] localTable;
UInt16 localhashInt;
localhashInt = seed;
localTable = new UInt16[256];
for (int i = 0; i < 256; i++)
{
UInt16 entry = (UInt16)i;
for (int j = 0; j < 8; j++)
if ((entry & 1) == 1)
entry = (ushort)((entry >> 1) ^ polynomial);
else
entry = (ushort)(entry >> 1);
localTable[i] = entry;
}
for (int i = 0; i < len; i++)
localhashInt = (ushort)((localhashInt >> 8) ^ localTable[data[i] ^ localhashInt & 0xff]);
hash = BitConverter.GetBytes(localhashInt);
StringBuilder crc16Output = new StringBuilder();
for (int i = 0; i < hash.Length; i++)
{
crc16Output.Append(hash[i].ToString("x2"));
}
return crc16Output.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);
}
}
}

223
SharpHash/Checksums/CRC32Context.cs Normal file
View File

@@ -0,0 +1,223 @@
//
// CRC32Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Text;
using System.IO;
using System;
namespace SharpHash.Checksums
{
/// <summary>
/// Provides a UNIX similar API to calculate CRC32.
/// </summary>
public class CRC32Context
{
//const UInt32 crc32Poly = 0xEDB88320;
//const UInt32 crc32Seed = 0xFFFFFFFF;
const UInt32 crc32Poly = 0xD8018001;
const UInt32 crc32Seed = 0x00000000;
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)
{
return Data(data, len, out hash, crc32Poly, crc32Seed);
}
/// <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>
/// <param name="polynomial">CRC polynomial</param>
/// <param name="seed">CRC seed</param>
public static string Data(byte[] data, uint len, out byte[] hash, UInt32 polynomial, UInt32 seed)
{
UInt32[] localTable;
UInt32 localhashInt;
localhashInt = seed;
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) ^ polynomial;
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);
}
}
}

219
SharpHash/Checksums/CRC64Context.cs Normal file
View File

@@ -0,0 +1,219 @@
//
// CRC64Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Text;
using System.IO;
using System;
namespace SharpHash.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)
{
return Data(data, len, out hash, crc64Poly, crc64Seed);
}
/// <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>
/// <param name="polynomial">CRC polynomial</param>
/// <param name="seed">CRC seed</param>
public static string Data(byte[] data, uint len, out byte[] hash, UInt64 polynomial, UInt64 seed)
{
UInt64[] localTable;
UInt64 localhashInt;
localhashInt = seed;
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) ^ polynomial;
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);
}
}
}

146
SharpHash/Checksums/MD5Context.cs Normal file
View File

@@ -0,0 +1,146 @@
//
// MD5Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace SharpHash.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);
}
}
}

146
SharpHash/Checksums/RIPEMD160Context.cs Normal file
View File

@@ -0,0 +1,146 @@
//
// RIPEMD160Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace SharpHash.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);
}
}
}

147
SharpHash/Checksums/SHA1Context.cs Normal file
View File

@@ -0,0 +1,147 @@
//
// SHA1Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace SharpHash.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);
}
}
}

146
SharpHash/Checksums/SHA256Context.cs Normal file
View File

@@ -0,0 +1,146 @@
//
// SHA256Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace SharpHash.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);
}
}
}

146
SharpHash/Checksums/SHA384Context.cs Normal file
View File

@@ -0,0 +1,146 @@
//
// SHA384Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace SharpHash.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);
}
}
}

146
SharpHash/Checksums/SHA512Context.cs Normal file
View File

@@ -0,0 +1,146 @@
//
// SHA512Context.cs
//
// Author:
// Natalia Portillo <claunia@claunia.com>
//
// Copyright (c) 2015 © Claunia.com
//
// 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/>.
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace SharpHash.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);
}
}
}

22
SharpHash/SharpHash.csproj
View File

@@ -35,6 +35,28 @@
<ItemGroup>
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Checksums\CRC16Context.cs" />
<Compile Include="Checksums\CRC32Context.cs" />
<Compile Include="Checksums\CRC64Context.cs" />
<Compile Include="Checksums\MD5Context.cs" />
<Compile Include="Checksums\RIPEMD160Context.cs" />
<Compile Include="Checksums\SHA1Context.cs" />
<Compile Include="Checksums\SHA256Context.cs" />
<Compile Include="Checksums\SHA384Context.cs" />
<Compile Include="Checksums\SHA512Context.cs" />
<Compile Include="BigEndianBitConverter.cs" />
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Folder Include="Checksums\" />
</ItemGroup>
<ProjectExtensions>
<MonoDevelop>
<Properties>
<Policies>
<DotNetNamingPolicy DirectoryNamespaceAssociation="PrefixedHierarchical" ResourceNamePolicy="MSBuild" />
</Policies>
</Properties>
</MonoDevelop>
</ProjectExtensions>
</Project>