C# Hash类代码示例

 public void Init()
 {
     SignerPublicKey = new Hash();
     BallotHash = new Hash();
     Signature = new Hash();
     LedgerCloseSequence = 0;
 }

        /// <summary>
        /// Метод реализующий авторизацию пользователя. Принимает 2 параметра: логин и пароль. Задаёт метод щифрования и устанавливает соединение с БД, передавая принятые параметры.
        /// Возрашает Boolean соединения.
        /// </summary>
        /// <param name="user">Логин</param>
        /// <param name="pass">Пароль</param>
        /// <returns>Успех или крах авторизации</returns>
        public static bool Authorization(string user, string pass)
        {
            //Задаём алгоритм хэширования пасса
            HashType = Hash.SHA1;

            MySqlDataReader dataReaderTemp = MySQL.UserAut(user, pass);
            while (dataReaderTemp.Read())
            {
                Id = dataReaderTemp.GetInt32("id_user");
                Login = dataReaderTemp.GetString("login_user");
                Role = dataReaderTemp.GetString("role");
            }

            if (!dataReaderTemp.HasRows)
            {
                MySQL.connection.Close();
                return false;
            }
            bool toReturn = false;
            switch (HashType)
            {
                case Hash.SHA1:
                    if (sha1(pass) == dataReaderTemp.GetString("pass_user"))
                        toReturn = true;
                    break;
                case Hash.MD5:
                    if (md5(pass) == dataReaderTemp.GetString("pass_user"))
                        toReturn = true;
                    break;
            }
            MySQL.connection.Close();
            MemoryManagement.FlushMemory();
            return toReturn;
        }

        public HeaderHash(Hash hash = null)
        {
            _names = new Dictionary<string, string>();

            hash = hash ?? new Hash();
            hash.Each(pair => this[pair.Key] = pair.Value);
        }

        public bool Compile(string path, string compileToFilePath = null)
        {
            using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read))
            {

                foreach (var kv in _config.CodeTemplates)
                {
                    var templateStr = kv.Key;
                    var exportPath = kv.Value;

                    // 生成代码
                    var template = Template.Parse(templateStr);
                    var topHash = new Hash();
                    topHash["NameSpace"] = _config.NameSpace;
                    var files = new List<Hash>();
                    topHash["Files"] = files;

                    var hash = DoCompiler(path, stream, compileToFilePath);
                    files.Add(hash);

                    if (!string.IsNullOrEmpty(exportPath))
                        File.WriteAllText(exportPath, template.Render(topHash));
                }

            }

            return true;
        }

 public static Hash Decode(IByteReader stream)
 {
     Hash decodedHash = new Hash();
       int Hashsize = 32;
       decodedHash.InnerValue = XdrEncoding.ReadFixOpaque(stream, (uint)Hashsize);
     return decodedHash;
 }

 public LeafDataType this[Hash hash]
 {
     get
     {
         return Values[hash];
     }
 }

        public static Hash/*!*/ Initialize([NotNull]BlockParam/*!*/ defaultProc, Hash/*!*/ self) {
            Assert.NotNull(self, defaultProc);

            self.DefaultProc = defaultProc.Proc;
            self.DefaultValue = null;
            return self;
        }

 public NetworkPacket(Hash publicKey_Src, PacketType type, byte[] Data)
 {
     PublicKeySource = publicKey_Src;
     Type = type;
     this.Data = Data;
     Token = new Hash();
 }

        public async Task<Package> GetAsync(long id, SemanticVersion version, Hash hash)
        {
            var key = prefix + id.ToString() + "/" + version.ToString();

            var ms = new MemoryStream();

            using (var blob = await bucket.GetAsync(key))
            {
                using (var data = blob.Open())
                {
                    await data.CopyToAsync(ms).ConfigureAwait(false);
                }
            }

            ms.Position = 0;
            
            var secret = SecretKey.Derive(password, hash.Data);

            var protector = new AesProtector(secret); // dispose?

            var stream = protector.DecryptStream(ms);

            #region Verify the hash

            var computedHash = Hash.ComputeSHA256(stream, true);

            if (computedHash != hash)
            {
                throw new IntegrityException(hash.Data, computedHash.Data);
            }

            #endregion

            return ZipPackage.FromStream(stream, false);
        }

 public NodeSocketData(Hash PublicKey, int ListenPort, string IP, string Name)
 {
     this.PublicKey = PublicKey;
     this.ListenPort = ListenPort;
     this.IP = IP;
     this.Name = Name;
 }

        public RemoteReferenceData(string name, Hash hash)
        {
            Verify.Argument.IsNeitherNullNorWhitespace(name, "name");

            _name = name;
            _hash = hash;
        }

        /* This function (for internal use only) locates an element in an
        ** hash table that matches the given key.  The hash for this key has
        ** already been computed and is passed as the 4th parameter.
        */
        static HashElem findElementGivenHash(
            Hash pH,       /* The pH to be searched */
            string pKey,   /* The key we are searching for */
            int nKey,      /* Bytes in key (not counting zero terminator) */
            u32 h         /* The hash for this key. */
            )
        {
            HashElem elem;                /* Used to loop thru the element list */
              int count;                    /* Number of elements left to test */

              if ( pH.ht != null && pH.ht[h] != null )
              {
            _ht pEntry = pH.ht[h];
            elem = pEntry.chain;
            count = (int)pEntry.count;
              }
              else
              {
            elem = pH.first;
            count = (int)pH.count;
              }
              while ( count-- > 0 && ALWAYS( elem ) )
              {
            if ( elem.nKey == nKey && elem.pKey.Equals( pKey, StringComparison.InvariantCultureIgnoreCase ) )
            {
              return elem;
            }
            elem = elem.next;
              }
              return null;
        }

		public bool Exists(Hash hash)
		{
			if (files.ContainsKey(hash)) return true;

			if (CheckAndAddOneFile(hash)) return true;
			return false;
		}

        public RemoteBranchData(string name, Hash sha1)
        {
            Verify.Argument.IsNeitherNullNorWhitespace(name, "name");

            _name = name;
            _sha1 = sha1;
        }

        public void Given_a_sequence_validation_transcoder_When_writen_to_the_transcoding_stream_Then_the_inner_stream_contains_the_previous_identifier_followed_by_the_data_written()
        {
            byte[] hashBytes = { 1, 2, 3, 4 };
            const string TestText = "Test";

            var hash = new Hash(hashBytes);
            var previousEventHashReader = new PreviousEventHashReader(hash);
            var sequenceValidationTranscodingStreamFactory = new SequenceValidationTranscodingStreamFactory(previousEventHashReader);

            using (var innerStream = new MemoryStream())
            using (var sequenceValidationTranscodingStream = sequenceValidationTranscodingStreamFactory.CreateTrancodingStream(innerStream))
            {
                var writer = new StreamWriter(sequenceValidationTranscodingStream);
                writer.Write(TestText);
                writer.Flush();
                sequenceValidationTranscodingStream.Flush();

                innerStream.Seek(0, SeekOrigin.Begin);

                var hashBuffer = new byte[4];
                innerStream.Read(hashBuffer, 0, 4);
                var reader = new StreamReader(innerStream);
                var actualText = reader.ReadToEnd();

                CollectionAssert.AreEqual(hashBytes, hashBuffer);
                Assert.AreEqual(TestText, actualText);
            }
        }