public static Hash160 GetScriptHashFromScript(byte[] script) { var scripthash = sha256.ComputeHash(script); scripthash = ripemd160.ComputeHash(scripthash); return(scripthash); }
public Address(Byte[] data, Byte version = PUBKEY) { SHA256 sha256 = new SHA256Managed(); RIPEMD160 ripemd160 = new RIPEMD160Managed(); switch (version) { case PUBKEY: pubKeyHash = ripemd160.ComputeHash(sha256.ComputeHash(data)); version = PUBKEYHASH; break; case SCRIPT: scriptHash = ripemd160.ComputeHash(sha256.ComputeHash(data)); version = SCRIPTHASH; break; case PUBKEYHASH: pubKeyHash = data; break; case SCRIPTHASH: scriptHash = data; break; } this.type = version; }
/// <summary> /// 获取密码hash值 /// </summary> /// <param name="password">原始密码</param> /// <param name="salt">加密盐</param> /// <returns>密码hash值</returns> private string GetHashPwd(string password, string salt) { var content = password + salt; var contentBytes = Encoding.UTF8.GetBytes(content); var part1 = Encoding.UTF8.GetBytes(salt); RIPEMD160Managed ripemd160Managed = new RIPEMD160Managed(); var part2 = ripemd160Managed.ComputeHash(contentBytes); var part3 = ripemd160Managed.ComputeHash(part1.Concat(part2).ToArray()); var part4 = SHA1.Create().ComputeHash(part3); return(Base58.Encode(part4)); }
/// <summary> /// Generate the initialization vector (IV) to feed to the encryption engine. /// </summary> /// <param name="passphrase">A string containing the passphrase</param> /// <param name="size">The size in bits of the IV to generate</param> /// <returns>An array of bytes containing the generated IV</returns> private static byte[] GenerateIV(string passphrase, int size) { try { // Complain if the passphrase is empty: if (passphrase == null || passphrase == String.Empty || passphrase == "") { throw new SecureFileException("The passphrase is empty"); } if (size <= 0 || size % 8 != 0) { throw new SecureFileException("The block size of the generated initialization " + "vector (IV) is invalid"); } // To generate the IV, we're going to do some funky things to the passphrase (and the // salt) to try and get something close to random but still derived. To do that, we'll // use the RIPEMD-160 hash engine. RIPEMD160Managed rip = new RIPEMD160Managed(); // Hash the password with RIPEMD-160 and convert the bytes to Base64: string passripper = Convert.ToBase64String(rip.ComputeHash(utf8.GetBytes(passphrase))); // Do the same thing with the salt: string saltripper = Convert.ToBase64String(rip.ComputeHash(utf8.GetBytes(salt))); // Reverse the passphrase using a StringBuilder, then hash that string as well using // the RIPEMD-160 / Base64 combo: StringBuilder sb = new StringBuilder(passphrase.Length); char[] ppBits = passphrase.ToCharArray(); for (int i = passphrase.Length - 1; i >= 0; i--) { sb.Append(ppBits[i]); } string passriprev = Convert.ToBase64String(rip.ComputeHash(utf8.GetBytes(sb.ToString()))); // Now we'll use SHA-512 and has the combined strings we generated above. We'll end up // with a 512-bit IV, which is probably overkill, but it should be good and "randomized" // but still derived from the passphrase. SHA512Managed sha = new SHA512Managed(); byte[] hashed = sha.ComputeHash(sha.ComputeHash(utf8.GetBytes(passriprev + saltripper + passripper))); // Now just get the first so many bytes (size divided by 8) and return them: byte[] iv = new byte[size / 8]; Array.Copy(hashed, iv, size / 8); return(iv); } catch (SecureFileException sfe) { throw sfe; } catch (Exception ex) { throw new SecureFileException("An unspecified error occurred: " + ex.ToString()); } }
void DoHash(string expectedHex, string textInput) { var hashAlgo = new RIPEMD160Managed(); var res = hashAlgo.ComputeHash(Encoding.ASCII.GetBytes(textInput)); Assert.Equal(expectedHex, res.ToHexString(), ignoreCase: true); }
public void HASH160() { InternalTestBigInteger(EVMOpCode.HASH160, (engine, a, cancel) => { byte[] hash; try { using (var sha = System.Security.Cryptography.SHA256.Create()) using (var ripe = new RIPEMD160Managed()) { hash = sha.ComputeHash(a == 0 ? new byte[] { } : a.ToByteArray()); hash = ripe.ComputeHash(hash); } } catch { Assert.AreEqual(engine.State, EVMState.Fault); cancel.Cancel = true; return; } Assert.IsTrue(engine.ResultStack.Pop <ByteArrayStackItem>().Value.SequenceEqual(hash)); }); }
/// <summary> /// Thanks http://gobittest.appspot.com/Address /// </summary> /// <param name="ecdsaPublickey">Standard format ecdsa public key taken from the blockchain</param> /// <returns></returns> private static string ComputeBitcoinAddress(byte[] ecdsaPublickey) { // step1: byte[32] -- sha256 ecdsaPublicKey // step2: byte[20] -- ripemd-160 hash step1 // step3: byte[21] -- add network bytes to step2 // step4: byte[32] -- sha256 step3 // step5: byte[32] -- sha256 step4 // step6: byte[4] -- get first four bytes of step 5 // step7: byte[25] -- add step6 to the end of step3 using (var sha256Managed = new SHA256Managed()) { using (var ripeMd160Managed = new RIPEMD160Managed()) { var step3 = new byte[21]; var step6 = new byte[4]; var step7 = new byte[25]; var step1 = sha256Managed.ComputeHash(ecdsaPublickey); var step2 = ripeMd160Managed.ComputeHash(step1); Array.Copy(step2, 0, step3, 1, 20); var step4 = sha256Managed.ComputeHash(step3); var step5 = sha256Managed.ComputeHash(step4); Array.Copy(step5, 0, step6, 0, 4); Array.Copy(step3, 0, step7, 0, 21); Array.Copy(step6, 0, step7, 21, 4); return(Base58Encoding.Encode(step7)); } } }
/// <summary> /// Create a hash value from a byte array's content. /// </summary> /// <param name="content">the literal content to evaluate for the hash.</param> /// <param name="method">The HashMethod enumeration for the evaluation</param> /// <returns>A hex-encoded value of the hash value</returns> public static string GetHash(byte[] content, HashMethod method) { HashAlgorithm hashString = new SHA1Managed(); switch (method) { case HashMethod.SHA1: break; case HashMethod.SHA256: hashString = new SHA256Managed(); break; case HashMethod.SHA384: hashString = new SHA384Managed(); break; case HashMethod.SHA512: hashString = new SHA512Managed(); break; case HashMethod.MD5: hashString = new MD5CryptoServiceProvider(); break; case HashMethod.RIPEMD: hashString = new RIPEMD160Managed(); break; default: throw new ArgumentException("Unrecognized hash encoding: " + method.ToString()); } return(ByteArrayToHex(hashString.ComputeHash(content))); }
/// <summary> /// Gets the MID. /// </summary> /// <returns></returns> /// <remarks>Documented by Dev08, 2009-02-12</remarks> public static string GetMID() { lock (mid) { if (mid != string.Empty) { return(mid); } string value; try { value = Identifier("Win32_BaseBoard", "SerialNumber") + Identifier("Win32_Processor", "ProcessorId"); } catch (MachineIDGenerationException mex) { value = getOsMID(); if (value == null) { throw mex; } } HashAlgorithm hashObject = new RIPEMD160Managed(); byte[] hash = hashObject.ComputeHash(Encoding.ASCII.GetBytes(value)); mid = ByteArrayToCompressedArrayString(hash).Substring(13, 8); return(mid); } }
public static Address GetLegacyAddress(string _private = "", bool _mainnet = true) { _private = _private == "" ? RandomPlus.RandomHex(64) : _private; BigInteger _privateInt = BigInteger.Parse("0" + _private, NumberStyles.HexNumber); byte[] _public = Secp256k1.PrivateKeyToPublicKey(_privateInt, false); RIPEMD160Managed _ripemd = new RIPEMD160Managed(); byte[] _ripemdHashed = _ripemd.ComputeHash(SHA.EncodeSHA256(_public)); byte[] _addedVersion = new byte[_ripemdHashed.Length + 1]; _addedVersion[0] = (byte)(_mainnet ? 0x00 : 0x6f); Array.Copy(_ripemdHashed, 0, _addedVersion, 1, _ripemdHashed.Length); byte[] _shaHashed = SHA.EncodeSHA256(SHA.EncodeSHA256(_addedVersion)); Array.Resize(ref _shaHashed, 4); byte[] _result = new byte[_addedVersion.Length + _shaHashed.Length]; Array.Copy(_addedVersion, 0, _result, 0, _addedVersion.Length); Array.Copy(_shaHashed, 0, _result, _addedVersion.Length, _shaHashed.Length); string _key1 = string.Join("", (_mainnet ? "80" : "ef"), _private); string _key2 = HexPlus.ByteArrayToHexString(SHA.EncodeSHA256(SHA.EncodeSHA256(HexPlus.HexStringToByteArray(_key1))).Take(4).ToArray()); Address _address = new Address { Text = Base58.Encode(_result), Public = HexPlus.ByteArrayToHexString(_public), Private = Base58.Encode(_key1 + _key2) }; return(_address); }
public static byte[] ToRIPEMD160Managed(this string s, Encoding encoding) { using (var ripemd160 = new RIPEMD160Managed()) { return(ripemd160.ComputeHash(s.GetBytes(encoding))); } }
public static Hash RipeMD160(Hash data) { using (RIPEMD160Managed rp = new RIPEMD160Managed()) { return(rp.ComputeHash(data)); } }
public static byte[] ToRIPEMD160(this byte[] s) { using (var ripemd160 = new RIPEMD160Managed()) { return(ripemd160.ComputeHash(s)); } }
public static Address GenerateAddress(out string _uncompressKey, string _existsPrivateKey = "", bool _mainNet = true) { string _netVersion = _mainNet ? "00" : "6f"; string _privateKey = string.IsNullOrWhiteSpace(_existsPrivateKey) ? Lion.RandomPlus.RandomHex() : _existsPrivateKey; _uncompressKey = _privateKey; BigInteger _bigPrivateKey = BigInteger.Parse("0" + _privateKey, System.Globalization.NumberStyles.HexNumber); var _publicKey = Secp256k1.PrivateKeyToPublicKey(_bigPrivateKey); SHA256Managed sha256 = new SHA256Managed(); var _ripemd = new RIPEMD160Managed(); var _ripemdHashed = _ripemd.ComputeHash(sha256.ComputeHash(_publicKey)); var _addedVersion = new byte[_ripemdHashed.Length + 1]; if (!_mainNet) { _addedVersion[0] = 0x6f; } Buffer.BlockCopy(_ripemdHashed, 0, _addedVersion, 1, _ripemdHashed.Length); var _doubleSha = sha256.ComputeHash(sha256.ComputeHash(_addedVersion)); Array.Resize(ref _doubleSha, 4); byte[] _result = new byte[_addedVersion.Length + _doubleSha.Length]; Buffer.BlockCopy(_addedVersion, 0, _result, 0, _addedVersion.Length); Buffer.BlockCopy(_doubleSha, 0, _result, _addedVersion.Length, _doubleSha.Length); Address _address = new Address(); _address.Text = Base58.Encode(_result); _address.PublicKey = Lion.HexPlus.ByteArrayToHexString(_publicKey); _address.PrivateKey = CompressPrivateKey(_privateKey, _mainNet); _address.Text = (_mainNet ? (_address.Text.StartsWith("1") ? "" : "1") : "") + _address.Text; return(_address); }
public static Address GenerateAddress(string _privateKey = "", bool _mainNet = true) { _privateKey = _privateKey == "" ? RandomPlus.RandomHex(64) : _privateKey; BigInteger _privateInt = BigInteger.Parse("0" + _privateKey, System.Globalization.NumberStyles.HexNumber); byte[] _publicKey = Secp256k1.PrivateKeyToPublicKey(_privateInt); SHA256Managed _sha256 = new SHA256Managed(); RIPEMD160Managed _ripemd = new RIPEMD160Managed(); byte[] _ripemdHashed = _ripemd.ComputeHash(_sha256.ComputeHash(_publicKey)); byte[] _addedVersion = new byte[_ripemdHashed.Length + 1]; _addedVersion[0] = (byte)(_mainNet ? 0x00 : 0x6f); Array.Copy(_ripemdHashed, 0, _addedVersion, 1, _ripemdHashed.Length); byte[] _shaHashed = _sha256.ComputeHash(_sha256.ComputeHash(_addedVersion)); Array.Resize(ref _shaHashed, 4); byte[] _result = new byte[_addedVersion.Length + _shaHashed.Length]; Array.Copy(_addedVersion, 0, _result, 0, _addedVersion.Length); Array.Copy(_shaHashed, 0, _result, _addedVersion.Length, _shaHashed.Length); string _key1 = string.Join("", (_mainNet ? "80" : "ef"), _privateKey); string _key2 = HexPlus.ByteArrayToHexString(SHA.EncodeSHA256(SHA.EncodeSHA256(HexPlus.HexStringToByteArray(_key1))).Take(4).ToArray()); Address _address = new Address(); _address.Text = Base58.Encode(_result); _address.PublicKey = HexPlus.ByteArrayToHexString(_publicKey); _address.PrivateKey = Base58.Encode(_key1 + _key2); _address.Text = (_mainNet ? (_address.Text.StartsWith("1") ? "" : "1") : "") + _address.Text; return(_address); }
private static byte[] RipeMD160(byte[] pubKey) { using (var hasher = new RIPEMD160Managed()) { return(hasher.ComputeHash(pubKey)); } }
public static byte[] ComputeRIPEMD160(byte[] data) { using (RIPEMD160Managed ripemd160 = new RIPEMD160Managed()) { return(ripemd160.ComputeHash(data)); } }
public void TestScriptHash() { using (var script = new ScriptBuilder ( EVMOpCode.PUSH0, EVMOpCode.RET )) using (var engine = CreateEngine(null)) { // Load script engine.LoadScript(script); // First check Assert.AreEqual(1, engine.InvocationStack.Count); // Check byte[] realHash; using (var sha = SHA256.Create()) using (var ripe = new RIPEMD160Managed()) { realHash = sha.ComputeHash(script); realHash = ripe.ComputeHash(realHash); } using (var context = engine.EntryContext) { Assert.IsTrue(context.ScriptHash.SequenceEqual(realHash)); } } }
public static byte[] RIPEMD160(byte[] data, int offset, int count) { using (var ripm = new RIPEMD160Managed()) { return(ripm.ComputeHash(data, offset, count)); } }
private byte[] HexToRipe(string data) { using (var ripe = new RIPEMD160Managed()) { return(ripe.ComputeHash(Encoding.Unicode.GetBytes(data))); } }
private string RIPEMD160Hash(string input) { var RIPEMD160Manager = new RIPEMD160Managed(); byte[] byteHash = RIPEMD160Manager.ComputeHash(ASCIIEncoding.ASCII.GetBytes(input)); return(BitConverter.ToString(byteHash).Replace("-", null)); }
public byte[] CreateOutputFromPublicKey(byte[] publicKey) { var sha256 = new SHA256Managed(); var ripemd160 = new RIPEMD160Managed(); var publicKeyHash = ripemd160.ComputeHash(sha256.ComputeHash(publicKey)); return(CreateOutputFromPublicKeyHash(publicKeyHash)); }
public static string GetRipeMd(string text) { byte[] bytes = Encoding.UTF8.GetBytes(text); RIPEMD160Managed rMD = new RIPEMD160Managed(); byte[] hashed = rMD.ComputeHash(bytes); return(Convert.ToBase64String(hashed)); }
/// <summary> /// Calculates RIPEMD160(SHA256(input)). This is used in Address calculations. /// </summary> public static byte[] Sha256Hash160(byte[] input) { var shaAlgorithm = new SHA256Managed(); var ripemdAlgorithm = new RIPEMD160Managed(); var sha256 = shaAlgorithm.ComputeHash(input); return(ripemdAlgorithm.ComputeHash(sha256, 0, sha256.Length)); }
public static byte[] PublicKeyHashed(byte[] pubK) { var pubHash = Sha.GenerateSha256String(ByteHelper.GetStringFromBytes(pubK)); var ripemd160 = new RIPEMD160Managed(); var ripemd160Hash = ripemd160.ComputeHash(Encoding.UTF8.GetBytes(pubHash)); return(ripemd160Hash); }
private static string GetKey(byte[] content) { RIPEMD160Managed ripemd160Managed = new RIPEMD160Managed(); var part1 = ripemd160Managed.ComputeHash(content); var part2 = SHA1.Create().ComputeHash(content); return(Base58.Encode(part1.Concat(part2).ToArray())); }
private static string ripemdencrypt(string phrase) { UTF8Encoding encoder = new UTF8Encoding(); RIPEMD160Managed ripemdhasher = new RIPEMD160Managed(); byte[] hashedDataBytes = ripemdhasher.ComputeHash(encoder.GetBytes(phrase)); return(byteArrayToString(hashedDataBytes)); }
private static byte[] GetDataHash(byte[] byteData, HashAlgorithm hashAlgorithm = HashAlgorithm.SHA256) { //choose any hash algorithm //SHA1Managed managedHash = new SHA1Managed(); //return managedHash.ComputeHash(Encoding.Unicode.GetBytes(sampleData)); // Create a SHA256 switch (hashAlgorithm) { case HashAlgorithm.MD5: using (MD5 md5Hash = MD5.Create()) { // ComputeHash - returns byte array return(md5Hash.ComputeHash(byteData)); } case HashAlgorithm.RIPEMD160: using (RIPEMD160 ripemd160Hash = new RIPEMD160Managed()) { // ComputeHash - returns byte array return(ripemd160Hash.ComputeHash(byteData)); } case HashAlgorithm.SHA1: using (SHA1 sha1Hash = SHA1.Create()) { // ComputeHash - returns byte array return(sha1Hash.ComputeHash(byteData)); } case HashAlgorithm.SHA256: using (SHA256 sha256Hash = SHA256.Create()) { // ComputeHash - returns byte array return(sha256Hash.ComputeHash(byteData)); } case HashAlgorithm.SHA384: using (SHA384 sha384Hash = SHA384.Create()) { // ComputeHash - returns byte array return(sha384Hash.ComputeHash(byteData)); } case HashAlgorithm.SHA512: using (SHA256 sha256Hash = SHA256.Create()) { // ComputeHash - returns byte array return(sha256Hash.ComputeHash(byteData)); } default: using (SHA256 sha256Hash = SHA256.Create()) { // ComputeHash - returns byte array return(sha256Hash.ComputeHash(byteData)); } } }
public void TestDoubleFree() { ExecutionContextBase context; byte[] realHash; using (var script = new ScriptBuilder(EVMOpCode.RET)) using (var engine = CreateEngine(null)) { // Load script engine.LoadScript(script); // Compute hash using (var sha = SHA256.Create()) using (var ripe = new RIPEMD160Managed()) { realHash = sha.ComputeHash(script); realHash = ripe.ComputeHash(realHash); } // Get Context context = engine.CurrentContext; // Create new array using (var ar = engine.CreateArray()) { // Create bool item and free using (var btest = engine.CreateBool(true)) { // Append item to array ar.Add(btest); } // Check Assert.IsTrue(ar[0] is BooleanStackItem b0 && b0.Value); } Assert.AreEqual(context.NextInstruction, EVMOpCode.RET); Assert.IsTrue(context.ScriptHash.SequenceEqual(realHash)); } // Check Assert.ThrowsException <ObjectDisposedException>(() => { Assert.AreEqual(context.NextInstruction, EVMOpCode.RET); }); Assert.ThrowsException <ObjectDisposedException>(() => { Assert.IsTrue(context.ScriptHash.SequenceEqual(realHash)); }); }
internal static string GetFileHash(string filePath, HashType type) { if (!File.Exists(filePath)) { return(string.Empty); } System.Security.Cryptography.HashAlgorithm hasher; switch (type) { case HashType.SHA1: default: hasher = new SHA1CryptoServiceProvider(); break; case HashType.SHA256: hasher = new SHA256Managed(); break; case HashType.SHA384: hasher = new SHA384Managed(); break; case HashType.SHA512: hasher = new SHA512Managed(); break; case HashType.MD5: hasher = new MD5CryptoServiceProvider(); break; case HashType.RIPEMD160: hasher = new RIPEMD160Managed(); break; } StringBuilder buff = new StringBuilder(); try { using (FileStream f = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 8192)) { hasher.ComputeHash(f); Byte[] hash = hasher.Hash; foreach (Byte hashByte in hash) { buff.Append(string.Format("{0:x2}", hashByte)); } } } catch (Exception exp) { string str = new System.Random(DateTime.Now.Second * DateTime.Now.Millisecond).Next().ToString(); // String.Format( "HashGenerator.GetFileHash.\r\n\t{0}", exp.Message ).Log( "Error reading file." + str ); return("Error reading file." + str); } return(buff.ToString()); }