diff --git a/SharpHash/BigEndianBitConverter.cs b/SharpHash/BigEndianBitConverter.cs
new file mode 100644
index 0000000..622ff96
--- /dev/null
+++ b/SharpHash/BigEndianBitConverter.cs
@@ -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);
+        }
+    }
+}
\ No newline at end of file
diff --git a/SharpHash/Checksums/CRC16Context.cs b/SharpHash/Checksums/CRC16Context.cs
new file mode 100644
index 0000000..c5e7892
--- /dev/null
+++ b/SharpHash/Checksums/CRC16Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/CRC32Context.cs b/SharpHash/Checksums/CRC32Context.cs
new file mode 100644
index 0000000..a719df2
--- /dev/null
+++ b/SharpHash/Checksums/CRC32Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/CRC64Context.cs b/SharpHash/Checksums/CRC64Context.cs
new file mode 100644
index 0000000..a9f13d1
--- /dev/null
+++ b/SharpHash/Checksums/CRC64Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/MD5Context.cs b/SharpHash/Checksums/MD5Context.cs
new file mode 100644
index 0000000..44a6f6c
--- /dev/null
+++ b/SharpHash/Checksums/MD5Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/RIPEMD160Context.cs b/SharpHash/Checksums/RIPEMD160Context.cs
new file mode 100644
index 0000000..0ed710a
--- /dev/null
+++ b/SharpHash/Checksums/RIPEMD160Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/SHA1Context.cs b/SharpHash/Checksums/SHA1Context.cs
new file mode 100644
index 0000000..c5a1855
--- /dev/null
+++ b/SharpHash/Checksums/SHA1Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/SHA256Context.cs b/SharpHash/Checksums/SHA256Context.cs
new file mode 100644
index 0000000..9e62e09
--- /dev/null
+++ b/SharpHash/Checksums/SHA256Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/SHA384Context.cs b/SharpHash/Checksums/SHA384Context.cs
new file mode 100644
index 0000000..245d25f
--- /dev/null
+++ b/SharpHash/Checksums/SHA384Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/Checksums/SHA512Context.cs b/SharpHash/Checksums/SHA512Context.cs
new file mode 100644
index 0000000..ca56873
--- /dev/null
+++ b/SharpHash/Checksums/SHA512Context.cs
@@ -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);
+        }
+    }
+}
+
diff --git a/SharpHash/SharpHash.csproj b/SharpHash/SharpHash.csproj
index 9e58cf5..73f700f 100644
--- a/SharpHash/SharpHash.csproj
+++ b/SharpHash/SharpHash.csproj
@@ -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>
\ No newline at end of file