Revision 0e1acc13 trunk/Pithos.Network/BlockHashAlgorithms.cs

b/trunk/Pithos.Network/BlockHashAlgorithms.cs
43 43
using System.Diagnostics.Contracts;
44 44
using System.IO;
45 45
using System.Reflection;
46
using System.Security.Cryptography;
46 47
using System.ServiceModel.Channels;
47 48
using System.Threading;
48 49
using System.Threading.Tasks;
49 50
using System.Threading.Tasks.Dataflow;
50
using OpenSSL.Crypto;
51

  
51 52

  
52 53
namespace Pithos.Network
53 54
{
......
251 252
            if (size == 0)
252 253
            {
253 254
                var buf = new byte[0];
254
                using (var hasher = new MessageDigestContext(MessageDigest.CreateByName(algorithm)))
255
                {                    
256
                    hasher.Init();
257
                    hashes[0] = hasher.Digest(buf);
255
                using (var hasher = HashAlgorithm.Create(algorithm))
256
                {
257
                    hashes[0] = hasher.ComputeHash(buf);
258 258
                    return hashes;
259 259
                }
260 260
            }
......
264 264
            var actualHashers = parallelism > blocks ? (byte)blocks : parallelism;
265 265

  
266 266
            var buffer = new byte[actualHashers][];
267
            var hashers = new MessageDigestContext[actualHashers];
267
            var hashers = new HashAlgorithm[actualHashers];
268 268
            var bufferManager = GetBufferManager(blockSize, actualHashers);
269 269
            for (var i = 0; i < actualHashers; i++)
270 270
            {
271 271
                buffer[i] = bufferManager.TakeBuffer(blockSize);// new byte[blockSize];
272
                hashers[i] = new MessageDigestContext(MessageDigest.CreateByName(algorithm));
273
                hashers[i].Init();
272
                hashers[i] = HashAlgorithm.Create(algorithm);                
274 273
            }
275 274
            try
276 275
            {
......
307 306

  
308 307
                                                            var hasher = hashers[idx];
309 308

  
310
                                                            byte[] hash;
309
                                                            byte[] hash=hasher.ComputeHash(buffer[idx],0,lastByteIndex+1);
310
/*
311 311
                                                            if (buffer[idx].Length == lastByteIndex || lastByteIndex==-1)
312 312
                                                                hash = hasher.Digest(buffer[idx]);
313 313
                                                            else
......
316 316
                                                                Buffer.BlockCopy(buffer[idx],0,buf,0,lastByteIndex+1);
317 317
                                                                hash = hasher.Digest(buf);
318 318
                                                            }
319
*/
319 320

  
320 321
                                                            
321 322
                                                            

Also available in: Unified diff