C# Cryptography.MD5类代码示例

		private SynchronizingFileStream(ITransactionalStorage transactionalStorage, string fileName,
										StorageStreamAccess storageStreamAccess, NameValueCollection metadata,
										IndexStorage indexStorage, StorageOperationsTask operations)
			: base(transactionalStorage, fileName, storageStreamAccess, metadata, indexStorage, operations)
		{
			md5Hasher = new MD5CryptoServiceProvider();
		}

 public Program()
 {
     md5Hasher = MD5.Create();
     InitializeComponent();
     folderSelector = new FolderBrowserDialog ();
     //Could help improve time from open to use?  Nah.
     //folderSelector.RootFolder = Environment.CurrentDirectory;
 }

 public override void AppendData(byte[] data, int offset, int count)
 {
     if (_md5 == null)
     {
         _md5 = MD5.Create();
     }
     _md5.TransformBlock(data, offset, count, null, 0);
 }

		public HMACSSLv3Verify(byte[] key)
		{
			this.HashSizeValue = 288;
			this.KeyValue = (byte[]) key.Clone();
			
			_md5 = new MD5CryptoServiceProvider();
			_sha1 = new SHA1CryptoServiceProvider();
		}

 public WriterWorkItem(FileStream stream, BinaryWriter writer, MD5 md5)
 {
     Stream = stream;
     Writer = writer;
     Buffer = new MemoryStream(2048);
     BufferWriter = new BinaryWriter(Buffer);
     MD5 = md5;
 }

 public WriterWorkItem(FileStream fileStream, UnmanagedMemoryStream memStream, MD5 md5)
 {
     _fileStream = fileStream;
     _memStream = memStream;
     _workingStream = (Stream)fileStream ?? memStream;
     Buffer = new MemoryStream(8192);
     BufferWriter = new BinaryWriter(Buffer);
     MD5 = md5;
 }

		/// <summary>
		/// Rfc 2104.
		/// </summary>
		/// <param name="rgbKey"></param>
		public HMACMD5 (byte[] rgbKey) 
		{
			HashSizeValue = 128;
			// Create the hash algorithms.
			hash1 = MD5.Create();
			hash2 = MD5.Create();

			this.Key = rgbKey;
		}    

        /// <summary>
        /// Frees an object for generating the hashes that was acquired from <see cref="GetHasher"/>,
        /// adding it back to the pool for later reuse.
        /// </summary>
        /// <param name="hasher">The object to free.</param>
        static void FreeHasher(MD5 hasher)
        {
            lock (_hashersSync)
            {
                if (log.IsDebugEnabled)
                    log.DebugFormat("Freeing hasher [object hash: {0}].", hasher.GetHashCode());

                _hashers.Push(hasher);
            }
        }

        public static byte[] CreateMD5Checksum(this Stream stream, bool startAtBeginning = true, MD5 md5 = null)
        {
            if (md5 == null)
                md5 = MD5.Create();

            if (startAtBeginning)
                stream.Seek(0, SeekOrigin.Begin);

            return md5.ComputeHash(stream);
        }

		public void FixtureSetUp () 
		{
			Assembly a = Assembly.GetExecutingAssembly ();
			hashEvidence = new Hash (a);

			md5 = MD5.Create ();
			digestMd5 = hashEvidence.GenerateHash (md5);

			sha1 = SHA1.Create ();
			digestSha1 = hashEvidence.GenerateHash (sha1);
		}

 public override byte[] GetHashAndReset()
 {
     if (_md5 == null)
     {
         _md5 = MD5.Create();
     }
     _md5.TransformFinalBlock(__emptyByteArray, 0, 0);
     var hash = _md5.Hash;
     _md5.Dispose();
     _md5 = null;
     return hash;
 }

 public static string GetMD5Hash(FileInfo fileInfo)
 {
     if(MD5Crypto == null)
     {
         MD5Crypto = MD5.Create();
     }
     using (FileStream fs = fileInfo.OpenRead())
     {
         byte[] output = MD5Crypto.ComputeHash(fs);
         string hashString = Convert.ToBase64String(output);
         return hashString;
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MD5HashStream"/> class.
        /// </summary>
        /// <param name="stream">Stream object.</param>
        /// <param name="lastTransferOffset">Offset of the transferred bytes.</param>
        /// <param name="md5hashCheck">Whether need to calculate MD5Hash.</param>
        public MD5HashStream(
            Stream stream,
            long lastTransferOffset,
            bool md5hashCheck)
        {
            this.stream = stream;
            this.md5hashOffset = lastTransferOffset;

            if ((0 == this.md5hashOffset)
                || (!md5hashCheck))
            {
                this.finishedSeparateMd5Calculator = true;
                this.succeededSeparateMd5Calculator = true;
            }
            else
            {
                this.semaphore = new SemaphoreSlim(1, 1);
            }

            if (md5hashCheck)
            {
                if (CloudStorageAccount.UseV1MD5)
                {
                    this.md5hash = new MD5CryptoServiceProvider();
                }
                else
                {
                    this.md5hash = new NativeMD5();
                }
            }

            if ((!this.finishedSeparateMd5Calculator)
                && (!this.stream.CanRead))
            {
                throw new NotSupportedException(string.Format(
                    CultureInfo.CurrentCulture,
                    Resources.StreamMustSupportReadException,
                    "Stream"));
            }

            if (!this.stream.CanSeek)
            {
                throw new NotSupportedException(string.Format(
                    CultureInfo.CurrentCulture,
                    Resources.StreamMustSupportSeekException,
                    "Stream"));
            }
        }

 //clientServer: true if random bytes should be processed as first the client bytes, then the server bytes
 //              false otherwise
 public Ssl3DeriveBytes(byte[] secret, byte[] clientRandom, byte[] serverRandom, bool clientServer)
 {
     if (secret == null || clientRandom == null || serverRandom == null)
         throw new ArgumentNullException();
     if (clientRandom.Length != 32 || serverRandom.Length != 32)
         throw new ArgumentException();
     m_Disposed = false;
     m_Secret = (byte[])secret.Clone();
     m_Random = new byte[64];
     if (clientServer) {
         Array.Copy(clientRandom, 0, m_Random, 0, 32);
         Array.Copy(serverRandom, 0, m_Random, 32, 32);
     } else {
         Array.Copy(serverRandom, 0, m_Random, 0, 32);
         Array.Copy(clientRandom, 0, m_Random, 32, 32);
     }
     m_MD5 = new MD5CryptoServiceProvider();
     m_SHA1 = new SHA1CryptoServiceProvider();
     Reset();
 }

        public static void ContinuousHashFor(MD5 md5, Stream s, int startPosition, long count)
        {
            Ensure.NotNull(md5, "md5");
            Ensure.Nonnegative(count, "count");

            if (s.Position != startPosition)
                s.Position = startPosition;

            var buffer = new byte[4096];
            long toRead = count;
            while (toRead > 0)
            {
                int read = s.Read(buffer, 0, (int)Math.Min(toRead, buffer.Length));
                if (read == 0)
                    break;

                md5.TransformBlock(buffer, 0, read, null, 0);
                toRead -= read;
            }
        }