private static HashAlgorithm DetermineHasher(HashType h)
{
HashAlgorithm ha = null;
switch (h)
{
case HashType.Sha1:
ha = new SHA1CryptoServiceProvider();
break;
case HashType.Sha256:
ha = new SHA256Managed();
break;
case HashType.Sha384:
ha = new SHA384Managed();
break;
case HashType.Sha512:
ha = new SHA512Managed();
break;
case HashType.Md5:
ha = new MD5CryptoServiceProvider();
break;
case HashType.Ripemd160:
ha = new RIPEMD160Managed();
break;
}
return(ha);
}
/// <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);
}
}
static void Main(string[] args)
{
if (args == null || args.Count() != 1)
{
Console.WriteLine("USAGE: CreateFileHash 'Filename.mp3'");
}
else
{
if (File.Exists(args[0].ToString()))
{
RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();
byte[] hashVal;
using (FileStream stream = File.Open(args[0].ToString(), FileMode.Open))
{
stream.Position = 0;
hashVal = myRIPEMD160.ComputeHash(stream);
string hashValueString = CreateStringFromByteArray(hashVal);
Console.WriteLine("The hash for this file is: {0}", hashValueString);
Console.WriteLine("The hash length is {0}", hashValueString.Length);
}
}
else
{
Console.WriteLine("File not found!");
}
Console.WriteLine("Press enter to continue");
Console.ReadLine();
}
}
private static byte[] ComputeRipeMdHash(byte[] data)
{
using (RIPEMD160 ripemd160 = RIPEMD160Managed.Create())
{
return(ripemd160.ComputeHash(data));
}
}
/// <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)));
}
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 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);
}
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;
}
public static Hash RipeMD160(Hash data)
{
using (RIPEMD160Managed rp = new RIPEMD160Managed())
{
return(rp.ComputeHash(data));
}
}
public HMACRIPEMD160 (byte[] key) {
m_hashName = "RIPEMD160";
m_hash1 = new RIPEMD160Managed();
m_hash2 = new RIPEMD160Managed();
HashSizeValue = 160;
base.InitializeKey(key);
}
public static string GenerateWalletAddress(string openkey, bool typeNetwork) //Метод для генерации адреса (openkey -открытый ключ в виде hex строки,typeNetwork true для основной сети и false для тестовой)
{
SHA256 sha = SHA256Managed.Create();
RIPEMD160 riPEMD160 = RIPEMD160Managed.Create();// Создаем экземпляры классов реализаций хеш алгоритмов
byte[] byteOpenKey = StringToByteArray(openkey);
// 1 шаг - применить к открытому ключу SHA-256
byte[] firstStepRes = sha.ComputeHash(byteOpenKey);
// 2 шаг - применить к результату шага 1 RIPEMD160
byte[] secondStepRes = riPEMD160.ComputeHash(firstStepRes);
// 3 шаг - добавить к результату шага 2 версионный бит(00 для основной сети и 6f для тестовой)
byte[] thirdStepRes = new byte[secondStepRes.Length + 1];
thirdStepRes[0] = typeNetwork ? (byte)0 : (byte)0x6F;
secondStepRes.CopyTo(thirdStepRes, 1);
// 4 шаг - два раза применить SHA-256 к результату шага 3
byte[] fourthStepRes = sha.ComputeHash(sha.ComputeHash(thirdStepRes));
// 5 шаг - взять первые четыре байта из шага 4(проверочная сумма адреса) и добавить их в конец результата шага 3
byte[] fifthStepRes = new byte[thirdStepRes.Length + 4];
thirdStepRes.CopyTo(fifthStepRes, 0);
for (int i = 0; i < 4; i++)
{
fifthStepRes[fifthStepRes.Length - 4 + i] = fourthStepRes[i];
}
return(ByteToBase58(fifthStepRes));//возвращаем ключ в base58 кодировке
}
// :$$$.контрольнаясумма
public static byte[] MD160(byte[] toHash)
{
using (RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create())
{
return(myRIPEMD160.ComputeHash(toHash));
}
}
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);
}
private string processFile(string file, ref string fileHash)
{
string fullPath = null;
FileStream fileStream = File.Open(file, FileMode.Open);
fileStream.Position = 0;
//Calculate hash.
RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();
var _hash = fileHash = Hash.GetMd5Hash(myRIPEMD160.ComputeHash(fileStream));
fileStream.Dispose();
//Check If exist already exist file in Database with the same hash
var existFile = Session.Advanced.DocumentQuery <Document>().Any(p => p.FileHash == _hash && p.Canceled == null);
if (!existFile)
{
fullPath = SaveFile(file);
}
else
{
var existingFileName = Session.Query <Document>().Where(d => d.FileHash == _hash && d.Canceled == null).FirstOrDefault().OriginalName;
logMessage(string.Format("The file {0} already exist in the repository with name {1}", Path.GetFileName(file), existingFileName));
}
return(fullPath);
}
static byte[] GetRMD160Hash(byte[] myByte)
{
RIPEMD160 _r160 = RIPEMD160Managed.Create();
byte[] _encrypted = _r160.ComputeHash(myByte);
; return(_encrypted);
}
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));
}
}
}
public static byte[] ToRIPEMD160Managed(this string s, Encoding encoding)
{
using (var ripemd160 = new RIPEMD160Managed())
{
return(ripemd160.ComputeHash(s.GetBytes(encoding)));
}
}
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 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);
}
private static byte[] RipeMD160(byte[] pubKey)
{
using (var hasher = new RIPEMD160Managed())
{
return(hasher.ComputeHash(pubKey));
}
}
private static HashAlgorithm GetAlgorithm(string algorithm)
{
switch (algorithm)
{
case "MD5":
return(new MD5CryptoServiceProvider());
case "RIPEMD160":
return(RIPEMD160Managed.Create());
case "SHA1":
return(new SHA1CryptoServiceProvider());
case "SHA256":
return(new SHA256CryptoServiceProvider());
case "SHA384":
return(new SHA384CryptoServiceProvider());
case "SHA512":
return(new SHA512CryptoServiceProvider());
default:
throw new Exception("Invalid Hash Algorithm Provided");
}
}
private byte[] HexToRipe(string data)
{
using (var ripe = new RIPEMD160Managed())
{
return(ripe.ComputeHash(Encoding.Unicode.GetBytes(data)));
}
}
public static byte[] ToRIPEMD160(this byte[] s)
{
using (var ripemd160 = new RIPEMD160Managed())
{
return(ripemd160.ComputeHash(s));
}
}
public static byte[] RIPEMD160(byte[] data, int offset, int count)
{
using (var ripm = new RIPEMD160Managed())
{
return(ripm.ComputeHash(data, offset, count));
}
}
private string RIPEMD160Hash(string input)
{
var RIPEMD160Manager = new RIPEMD160Managed();
byte[] byteHash = RIPEMD160Manager.ComputeHash(ASCIIEncoding.ASCII.GetBytes(input));
return(BitConverter.ToString(byteHash).Replace("-", null));
}
public static byte[] ComputeRIPEMD160(byte[] data)
{
using (RIPEMD160Managed ripemd160 = new RIPEMD160Managed())
{
return(ripemd160.ComputeHash(data));
}
}
public static string FromString(string input, HashType hashtype)
{
Byte[] clearBytes;
Byte[] hashedBytes;
string output = String.Empty;
switch (hashtype)
{
case HashType.RIPEMD160:
clearBytes = new UTF8Encoding().GetBytes(input);
RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();
hashedBytes = myRIPEMD160.ComputeHash(clearBytes);
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.MD5:
clearBytes = new UTF8Encoding().GetBytes(input);
hashedBytes = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(clearBytes);
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA1:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
sha1.ComputeHash(clearBytes);
hashedBytes = sha1.Hash;
sha1.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA256:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA256 sha256 = new SHA256Managed();
sha256.ComputeHash(clearBytes);
hashedBytes = sha256.Hash;
sha256.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA384:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA384 sha384 = new SHA384Managed();
sha384.ComputeHash(clearBytes);
hashedBytes = sha384.Hash;
sha384.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
case HashType.SHA512:
clearBytes = Encoding.UTF8.GetBytes(input);
SHA512 sha512 = new SHA512Managed();
sha512.ComputeHash(clearBytes);
hashedBytes = sha512.Hash;
sha512.Clear();
output = BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
break;
}
return(output);
}
public static void Main(String[] args)
{
string directory = "";
if (args.Length < 1)
{
FolderBrowserDialog fbd = new FolderBrowserDialog();
DialogResult dr = fbd.ShowDialog();
if (dr == DialogResult.OK)
{
directory = fbd.SelectedPath;
}
else
{
Console.WriteLine("No directory selected.");
return;
}
}
else
{
directory = args[0];
}
try
{
// Create a DirectoryInfo object representing the specified directory.
DirectoryInfo dir = new DirectoryInfo(directory);
// Get the FileInfo objects for every file in the directory.
FileInfo[] files = dir.GetFiles();
// Initialize a RIPE160 hash object.
RIPEMD160 myRIPEMD160 = RIPEMD160Managed.Create();
byte[] hashValue;
// Compute and print the hash values for each file in directory.
foreach (FileInfo fInfo in files)
{
// Create a fileStream for the file.
FileStream fileStream = fInfo.Open(FileMode.Open);
// Be sure it's positioned to the beginning of the stream.
fileStream.Position = 0;
// Compute the hash of the fileStream.
hashValue = myRIPEMD160.ComputeHash(fileStream);
// Write the name of the file to the Console.
Console.Write(fInfo.Name + ": ");
// Write the hash value to the Console.
PrintByteArray(hashValue);
// Close the file.
fileStream.Close();
}
return;
}
catch (DirectoryNotFoundException)
{
Console.WriteLine("Error: The directory specified could not be found.");
}
catch (IOException)
{
Console.WriteLine("Error: A file in the directory could not be accessed.");
}
}
public byte[] CreateOutputFromPublicKey(byte[] publicKey)
{
var sha256 = new SHA256Managed();
var ripemd160 = new RIPEMD160Managed();
var publicKeyHash = ripemd160.ComputeHash(sha256.ComputeHash(publicKey));
return(CreateOutputFromPublicKeyHash(publicKeyHash));
}
public HMACRIPEMD160(byte[] key)
{
m_hashName = "RIPEMD160";
m_hash1 = new RIPEMD160Managed();
m_hash2 = new RIPEMD160Managed();
HashSizeValue = 160;
base.InitializeKey(key);
}
