C# SHA256Managed.ComputeHash方法代码示例

        private static readonly string[] Salts = { "QJhwzAtXL", "XzUhGYdFp", "NoCanLook" }; //lol, new salt isn't really being used

        #endregion Fields

        #region Methods

        public static List<byte[]> Retrieve(SQLiteConnection connection)
        {
            using (var sha256 = new SHA256Managed())
            {
                var combinedSalt = Salts[1] + Salts[2]; //XzUhGYdFpNoCanLook
                var combinedHash = sha256.ComputeHash(Encoding.ASCII.GetBytes(combinedSalt)).ToHexString(); //8bd007187bc88b3a2e1371b6f5f4fa0719f8b45104841b382b18e671f8ba2057
                var realSalt = combinedHash.Substring(11, 9); //88b3a2e13
                var macs = NetworkInterface.GetAllNetworkInterfaces()
                    .Where(iface => iface.NetworkInterfaceType != NetworkInterfaceType.Loopback)
                    .Select(iface => iface.GetPhysicalAddress().ToMacString())
                    .Distinct()
                    .Where(addr => !string.IsNullOrEmpty(addr))
                    .ToList();
                var secrets = macs.Select(mac => realSalt + mac).ToList(); //88b3a2e13FF:FF:FF:FF:FF:FF //should select first active ethernet adapter
                var deviceIds = secrets.Select(secret => sha256.ComputeHash(Encoding.ASCII.GetBytes(secret)).ToHexString()).ToList();

                var userIds = new List<string>();
                using (var cmd = new SQLiteCommand("select UserID from user", connection))
                using (var reader = cmd.ExecuteReader())
                    while (reader.Read())
                        userIds.Add(reader["UserID"] as string);

                var result = (
                    from userId in userIds
                    from deviceId in deviceIds
                    select Encoding.UTF8.GetBytes((deviceId + userId).Trim()) into key
                    select sha256.ComputeHash(key) into hash
                    select hash.Copy(hash.Length - 16)
                ).ToList();

                //var strResult = result.Select(b => b.ToHexString()).Distinct().ToList();
                return result;
            }
        }

 public static String FromByteArray(Byte[] b, Byte version)
 {
     SHA256 sha256 = new SHA256Managed();
     b = (new Byte[] { version }).Concat(b).ToArray();
     Byte[] hash = sha256.ComputeHash(sha256.ComputeHash(b)).Take(4).ToArray();
     return Base58String.FromByteArray(b.Concat(hash).ToArray());
 }

        public static CompareResult Compare(Bitmap bmp1, Bitmap bmp2)
        {
            CompareResult cr = CompareResult.ciCompareOk;

            //Test to see if we have the same size of image
            if (bmp1.Size != bmp2.Size)
            {
                cr = CompareResult.ciSizeMismatch;
            }
            else
            {
                //Convert each image to a byte array
                System.Drawing.ImageConverter ic =
                       new System.Drawing.ImageConverter();
                byte[] btImage1 = new byte[1];
                btImage1 = (byte[])ic.ConvertTo(bmp1, btImage1.GetType());
                byte[] btImage2 = new byte[1];
                btImage2 = (byte[])ic.ConvertTo(bmp2, btImage2.GetType());

                //Compute a hash for each image
                SHA256Managed shaM = new SHA256Managed();
                byte[] hash1 = shaM.ComputeHash(btImage1);
                byte[] hash2 = shaM.ComputeHash(btImage2);

                //Compare the hash values
                for (int i = 0; i < hash1.Length && i < hash2.Length
                                  && cr == CompareResult.ciCompareOk; i++)
                {
                    if (hash1[i] != hash2[i])
                        cr = CompareResult.ciPixelMismatch;
                }
            }
            return cr;
        }

		private IodineObject sha256 (VirtualMachine vm, IodineObject self, IodineObject[] args)
		{
			if (args.Length <= 0) {
				vm.RaiseException (new IodineArgumentException (1));
				return null;
			}

			byte[] bytes = new byte[]{};
			byte[] hash = null;

			SHA256Managed hashstring = new SHA256Managed();

			if (args[0] is IodineString) {
				bytes = System.Text.Encoding.UTF8.GetBytes (args[0].ToString ());
				hash = hashstring.ComputeHash(bytes);
			} else if (args[0] is IodineByteArray) {
				bytes = ((IodineByteArray)args[0]).Array;
				hash = hashstring.ComputeHash(bytes);
			} else if (args[0] is IodineStream) {
				hash = hashstring.ComputeHash(((IodineStream)args[0]).File);
			} else {
				vm.RaiseException (new IodineTypeException ("Str"));
				return null;
			}

			return new IodineByteArray (hash);
		}

        public static void DoubleSha256Test()
        {
            var innerExpected = new byte[] {
                0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
                0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
                0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
                0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad,
            };
            var vector = Encoding.ASCII.GetBytes("abc");
            var hasher = new SHA256Managed();
            var innerDigest = hasher.ComputeHash(vector);

            Assert.Equal(innerDigest, innerExpected);

            var outerExpected = new byte[] {
                0x4f, 0x8b, 0x42, 0xc2, 0x2d, 0xd3, 0x72, 0x9b,
                0x51, 0x9b, 0xa6, 0xf6, 0x8d, 0x2d, 0xa7, 0xcc,
                0x5b, 0x2d, 0x60, 0x6d, 0x05, 0xda, 0xed, 0x5a,
                0xd5, 0x12, 0x8c, 0xc0, 0x3e, 0x6c, 0x63, 0x58,
            };
            var outerDigest = hasher.ComputeHash(innerDigest);

            Assert.Equal(outerDigest, outerExpected);

            Assert.Equal(outerDigest, WalletSeed.DoubleSha256(vector));
        }

 public static PrivateKey FromMiniKey(String s)
 {
     SHA256 sha256 = new SHA256Managed();
     Byte[] b = Encoding.ASCII.GetBytes(s);
     if (sha256.ComputeHash(b.Concat(new Byte[] { (Byte)'?' }).ToArray()).First() != 0x00)
         throw new ArgumentException("Invalid miniKey");
     return new PrivateKey(sha256.ComputeHash(b));
 }

 // Returned array contains the double SHA256 hash.
 public static byte[] DoubleSha256(byte[] value)
 {
     using (var hasher = new SHA256Managed())
     {
         var intermediateHash = hasher.ComputeHash(value);
         return hasher.ComputeHash(intermediateHash);
     }
 }

 /// <summary>
 /// Calculates SHA256(SHA256(byte range 1 + byte range 2)).
 /// </summary>
 public static byte[] DoubleDigestTwoBuffers(byte[] input1, int offset1, int length1, byte[] input2, int offset2, int length2)
 {
     var algorithm = new SHA256Managed();
     var buffer = new byte[length1 + length2];
     Array.Copy(input1, offset1, buffer, 0, length1);
     Array.Copy(input2, offset2, buffer, length1, length2);
     var first = algorithm.ComputeHash(buffer, 0, buffer.Length);
     return algorithm.ComputeHash(first);
 }

 public static byte[] Hash(byte[] bytes, int offset, int count)
 {
     using (var x = new SHA256Managed())
     {
         var hash1 = x.ComputeHash(bytes, offset, count);
         var hash2 = x.ComputeHash(hash1);
         return hash2;
     }
 }

 public static Byte[] ToByteArray(String s, out Byte version)
 {
     SHA256 sha256 = new SHA256Managed();
     Byte[] b = Base58String.ToByteArray(s);
     Byte[] hash = sha256.ComputeHash(sha256.ComputeHash(b.Take(b.Length - 4).ToArray()));
     if (!hash.Take(4).SequenceEqual(b.Skip(b.Length - 4).Take(4)))
         throw new ArgumentException("Invalid Base58Check String");
     version = b.First();
     return b.Skip(1).Take(b.Length - 5).ToArray();
 }

 public Message(String command, IPayload payload, bool TestNet = false)
 {
     SHA256 sha256 = new SHA256Managed();
     Byte[] payloadBytes = payload.ToBytes();
     if (!TestNet)
         this.magic = 0xD9B4BEF9;
     else
         this.magic = 0x0709110B;
     this.command = Encoding.ASCII.GetBytes(command).Concat(new Byte[12 - command.Length]).ToArray();
     this.length = (UInt32)payloadBytes.Length;
     this.checksum = sha256.ComputeHash(sha256.ComputeHash(payloadBytes)).Take(4).ToArray();
     this.payload = payload;
 }

 public static string GetHash(string secretKey,string date, string body)
 {
     byte[] hashArray;
     using (var encryptor = new SHA256Managed())
     {
         var payloadByteArray = Encoding.UTF8.GetBytes(string.Concat(secretKey,secretKey));
         var payload = string.Concat(Convert.ToBase64String(encryptor.ComputeHash(payloadByteArray)), date, body);
         payloadByteArray = Encoding.UTF8.GetBytes(payload);
         hashArray = encryptor.ComputeHash(payloadByteArray);
     }
     var hash = Convert.ToBase64String(hashArray);
     return hash;
 }

        public string HashFile(string path)
        {
            try
            {
                var fi = new FileInfo(path);
                byte[] bytes = new byte[3072];
                string raw = "";
                string hash = "";
                var sha256 = new SHA256Managed();

                FileStream fs = System.IO.File.OpenRead(path);

                if (fi.Length > 3072)
                {
                    long middle = (long)Math.Floor((double)fi.Length / (double)2);
                    long last = fi.Length - 1024;

                    fs.Seek(0, SeekOrigin.Begin);
                    fs.Read(bytes, 0, 1024);
                    fs.Seek(middle, SeekOrigin.Current);
                    fs.Read(bytes, 1024, 1024);
                    fs.Seek(last, SeekOrigin.Current);
                    fs.Read(bytes, 2048, 1024);

                    raw = ByteToString(bytes);

                    hash = ByteToString(sha256.ComputeHash(Encoding.UTF8.GetBytes(raw))) + fi.Length.ToString();
                }
                else
                {
                    hash = ByteToString(sha256.ComputeHash(fs)) + fi.Length.ToString();
                }

                fs.Close();
                return hash;
            }
            catch (FileNotFoundException ex)
            {
                // file not found
                Logger.Write(ex.Message);
            }
            catch (IOException ex)
            {
                // file could not be accessed
                // warn user and try again on OK
                Logger.Write("Error, " + ex.Message);
            }
            return null;
        }

        public override string Encrypt(string data)
        {
            SHA256Managed sha256hasher = new SHA256Managed();

            try
            {
                UTF8Encoding encoder = new UTF8Encoding();

                byte[] hashedDataBytes = sha256hasher.ComputeHash(encoder.GetBytes(string.Format(base.hashFormat, data)));

                return Convert.ToBase64String(hashedDataBytes);
            }
            catch (Exception e)
            {
                var exception = new CryptologyException("SHA256Encryptor.Encrypt()", "An error occurred while encrypting.", e);
                exception.Data.Add("hashFormat", hashFormat);
                exception.Data.Add("data", data);

                throw exception;
            }
            finally
            {
                sha256hasher.Dispose();
            }
        }

 public static string Sha256(string password)
 {
     SHA256Managed crypt = new SHA256Managed();
     string hash = String.Empty;
     byte[] crypto = crypt.ComputeHash(Encoding.UTF8.GetBytes(password), 0, Encoding.UTF8.GetByteCount(password));
     return crypto.Aggregate(hash, (current, bit) => current + bit.ToString("x2"));
 }