Synnefo » Pithos MS Client

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.IO;

using System.Runtime.Remoting.Metadata.W3cXsd2001;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

using System.Linq;

namespace Pithos.Network

{

    public static class Signature

    {

        public static string CalculateMD5(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            Contract.EndContractBlock();

            //DON'T calculate hashes for folders

            if (Directory.Exists(path))

                return "";

            string hash;

            using (var hasher = MD5.Create())

            using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, true))

            {

                var hashBytes = hasher.ComputeHash(stream);

                hash = hashBytes.ToHashString();

            }

            return hash;

        }

/*

        public static string BytesToString(byte[] hashBytes)

        {

            var shb=new SoapHexBinary(hashBytes);

            return shb.ToString();

        }

        public static byte[] StringToBytes(string hash)

        {

            var shb=SoapHexBinary.Parse(hash);

            return shb.Value;

        }

*/

        public static byte[] ToBytes(this string hash)

        {

            var shb = SoapHexBinary.Parse(hash);

            return shb.Value;

        }

        public static string ToHashString(this byte[] hashBytes)

        {

            var shb = new SoapHexBinary(hashBytes);

            return shb.ToString();

        }

        /// <summary>

        /// Calculates a file's tree hash synchronously, using the specified block size

        /// </summary>

        /// <param name="filePath">Path to an existing file</param>

        /// <param name="blockSize">Block size used to calculate leaf hashes</param>

        /// <param name="algorithm"></param>

        /// <returns>A <see cref="TreeHash"/> with the block hashes and top hash</returns>

        public static TreeHash CalculateTreeHash(string filePath, int blockSize, string algorithm)

        {

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (blockSize<=0)

                throw new ArgumentOutOfRangeException("blockSize","blockSize must be a value greater than zero ");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            //DON'T calculate hashes for folders

            if (Directory.Exists(filePath))

                return null;

            var list = new List<byte[]>();

            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, blockSize, false))

            using (var hasher = HashAlgorithm.Create(algorithm))

            {

                int read;

                var buffer = new byte[blockSize];            

                while ((read = stream.Read(buffer, 0, blockSize)) > 0)

                {

                    var hash = hasher.ComputeHash(buffer, 0, read);

                    list.Add(hash);

                }

                return new TreeHash(algorithm) { Hashes = list,                    

                    BlockSize = blockSize, 

                    Bytes = stream.Length};

            }            

        }

        public static Task<TreeHash> CalculateTreeHashAsync(string filePath, int blockSize,string algorithm)

        {

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (blockSize <= 0)

                throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            //DON'T calculate hashes for folders

            if (Directory.Exists(filePath))

                return Task.Factory.StartNew(()=>new TreeHash(algorithm));

            var hashes = new ConcurrentDictionary<int, byte[]>();

            var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, blockSize, true);

            return CalculateBlockHashesAsync(stream, blockSize, algorithm,hashes)

                .ContinueWith(t => {

                                        var length = stream.Length;

                                       stream.Close();

                                       var list= t.Result.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToList();                                       

                                       return new TreeHash(algorithm) { Hashes = list,                                           

                                           BlockSize = blockSize, 

                                           Bytes = length };

                });

        }

      /*  public static byte[] CalculateTopHash(IEnumerable<byte[]> hashMap, string algorithm)

        {

            if (hashMap == null)

                throw new ArgumentNullException("hashMap");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            var hashCount = hashMap.Count();

            if (hashCount == 0)

                return null;

            using (var hasher = HashAlgorithm.Create(algorithm))

            {

                var i = 0;

                var count = hashCount;

                foreach (var block in hashMap)

                {

                    if (i++ != count - 1)

                        hasher.TransformBlock(block, 0, block.Length, null, 0);

                    else

                        hasher.TransformFinalBlock(block, 0, block.Length);

                }

                var finalHash = hasher.Hash;

                return finalHash;

            }

        }*/

        public static byte[] CalculateTopHash(IEnumerable<byte[]> hashMap, string algorithm)

        {

            if (hashMap == null)

                throw new ArgumentNullException("hashMap");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            var hashCount = hashMap.Count();

            if (hashCount == 0)

                return null;

            if (hashCount == 1)

                return hashMap.First();

            var newHashes=new List<byte[]>();

            var leafs =Math.Pow(2, Math.Log(hashCount,2)+1);

            for (int i = 0; i < leafs;i+=2 )

            {

                using (var hasher = HashAlgorithm.Create(algorithm))

                {

                    var block1 = i >hashCount - 1 ? new byte[hashMap.First().Length] : hashMap.ElementAt(i);

                    var block2 = i>hashCount-2 ? new byte[block1.Length] : hashMap.ElementAt(i+1);

                    hasher.TransformBlock(block1, 0, block1.Length, null, 0);

                    hasher.TransformFinalBlock(block2, 0, block2.Length);                        

                    var finalHash = hasher.Hash;

                    newHashes.Add(finalHash);

                }                    

            }

            return CalculateTopHash(newHashes, algorithm);                   

        }

        public static string CalculateTopHash(string hashString, string algorithm)

        {

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            if (String.IsNullOrWhiteSpace(hashString))

                return String.Empty;

            using (var hasher = HashAlgorithm.Create(algorithm))

            {

                var bytes=Encoding.ASCII.GetBytes(hashString.ToLower());

                var hash=hasher.ComputeHash(bytes);

                return hash.ToHashString();

            }

        }

        private static Task<ConcurrentDictionary<int, byte[]>> CalculateBlockHashesAsync(FileStream stream, int blockSize, string algorithm, ConcurrentDictionary<int, byte[]> hashes, int index = 0)

        {

            if (stream==null)

                throw new ArgumentNullException("stream");

            if (hashes==null)

                throw new ArgumentNullException("hashes");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            if (blockSize <= 0)

                throw new ArgumentOutOfRangeException("blockSize", "blockSize must be a value greater than zero ");

            if (index< 0)

                throw new ArgumentOutOfRangeException("index", "index must be a non-negative value");

            Contract.EndContractBlock();

            var buffer = new byte[blockSize];

            return stream.ReadAsync(buffer, 0, blockSize).ContinueWith(t =>

            {

                var read = t.Result;

                var nextTask = read == blockSize

                                    ? CalculateBlockHashesAsync(stream, blockSize, algorithm, hashes, index + 1) 

                                    : Task.Factory.StartNew(() => hashes);

                using (var hasher = HashAlgorithm.Create(algorithm))

                {

                    var hash = hasher.ComputeHash(buffer, 0, read);

                    hashes[index]=hash;

                }

                return nextTask;

            }).Unwrap();

        }

        public static byte[] CalculateHash(byte[] buffer,string algorithm)

        {

            if (buffer == null)

                throw new ArgumentNullException("buffer");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            using (var hasher = HashAlgorithm.Create(algorithm))

            {

                var hash = hasher.ComputeHash(buffer, 0, buffer.Length);

                return hash;

            }        

        }

    }

}