/// <summary> Construct from base58 bitshares public key </summary>
///
/// <remarks> Paul, 08/12/2014. </remarks>
///
/// <param name="base58BtsPubKey"> The base 58 bts pub key. </param>
public BitsharesPubKey(string base58BtsPubKey)
{
m_ripe = RIPEMD160.Create();
if (base58BtsPubKey.Length == 54)
{
base58BtsPubKey = base58BtsPubKey.Substring(4, base58BtsPubKey.Length - 4);
}
else if (base58BtsPubKey.Length == 53)
{
base58BtsPubKey = base58BtsPubKey.Substring(3, base58BtsPubKey.Length - 3);
}
else
{
throw new NotImplementedException();
}
byte[] data = Base58.ToByteArray(base58BtsPubKey);
Debug.Assert(data.Length == 37);
byte[] pubkeyCheck = RIPEMD160.Create().ComputeHash(data, 0, 33);
// check the hash first four bytes are equal to the last four bytes of the pub key
for (int i = 0; i < 4; i++)
{
if (pubkeyCheck[i] != data[i + 33])
{
throw new BadChecksumException();
}
}
m_compressed = new byte[33];
Array.Copy(data, 0, m_compressed, 0, m_compressed.Length);
}
public void RIPEMD160Empty()
{
var ripemd160 = RIPEMD160.Create();
var result = ripemd160.ComputeHash(string.Empty.ToByteArray());
Assert.AreEqual("9c1185a5c5e9fc54612808977ee8f548b2258d31", result.ToHexString());
}
public void RIPEMD160LowerLetters()
{
var ripemd160 = RIPEMD160.Create();
var result = ripemd160.ComputeHash("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq".ToByteArray());
Assert.AreEqual("12a053384a9c0c88e405a06c27dcf49ada62eb2b", result.ToHexString());
}
static PublicKey FromStringOrThrow(string publicKey, string addressPrefix = null)
{
if (addressPrefix.IsNull())
{
addressPrefix = ChainConfig.AddressPrefix;
}
var prefix = publicKey.Substring(0, addressPrefix.Length);
Assert.Equal(
addressPrefix, prefix,
string.Format("Expecting key to begin with {0}, instead got {1}", addressPrefix, prefix)
);
publicKey = publicKey.Substring(addressPrefix.Length);
var buffer = Base58.Decode(publicKey);
var checksum = buffer.Slice(buffer.Length - 4);
buffer = buffer.Slice(0, buffer.Length - 4);
var newChecksum = RIPEMD160.Create().HashAndDispose(buffer);
newChecksum = newChecksum.Slice(0, 4);
var isEqual = checksum.DeepEqual(newChecksum); // invalid checksum
if (!isEqual)
{
throw new InvalidOperationException("Checksum did not match");
}
return(FromBuffer(buffer));
}
public static HashAlgorithm GetHashAlgorithmByType(DigestType dgType)
{
HashAlgorithm ha = null;
switch (dgType)
{
case DigestType.MD5:
ha = MD5.Create();
break;
case DigestType.SHA1:
ha = SHA1.Create();
break;
case DigestType.SHA256:
ha = SHA256.Create();
break;
case DigestType.SHA384:
ha = SHA384.Create();
break;
case DigestType.SHA512:
ha = SHA512.Create();
break;
case DigestType.RIPEMD160:
ha = RIPEMD160.Create();
break;
}
return(ha);
}
protected override void BeginProcessing()
{
base.BeginProcessing();
switch (HashType.ToLower())
{
case "md5":
Algorithm = MD5.Create();
break;
case "sha1":
Algorithm = SHA1.Create();
break;
case "sha256":
Algorithm = SHA256.Create();
break;
case "sha384":
Algorithm = SHA384.Create();
break;
default:
case "sha512":
Algorithm = SHA512.Create();
break;
case "ripemd160":
Algorithm = RIPEMD160.Create();
break;
}
}
/// <summary>
/// Creates a <see cref="HashAlgorithm"/> for the specified <paramref name="hashType"/>
/// </summary>
/// <param name="hashType">Type of the hash.</param>
/// <returns></returns>
public static HashAlgorithm CreateHashAlgorithm(HashType hashType)
{
switch (GetHashType(hashType))
{
case HashType.MD5:
return(MD5.Create());
case HashType.SHA1:
return(SHA1.Create());
case HashType.SHA256:
return(SHA256.Create());
case HashType.SHA512:
return(SHA512.Create());
case HashType.SHA384:
return(SHA384.Create());
case HashType.RipeMD160:
return(RIPEMD160.Create());
default:
throw new ArgumentException("Invalid hashtype", "hashType");
}
}
public void Calculate(Stream _stream)
{
if (chkKey.Checked)
{
if (!txtKey.IsValid)
{
HashFields_Empty();
HashFields_ResetColour();
txtKey.BackColor = Color.Salmon;
return;
}
byte[] abyKey = txtKey.ByteArray;
ComputeHash(txtMD5, new HMACMD5(abyKey), _stream);
ComputeHash(txtRIPEMD160, new HMACRIPEMD160(abyKey), _stream);
ComputeHash(txtSHA1, new HMACSHA1(abyKey), _stream);
ComputeHash(txtSHA256, new HMACSHA256(abyKey), _stream);
ComputeHash(txtSHA384, new HMACSHA384(abyKey), _stream);
ComputeHash(txtSHA512, new HMACSHA512(abyKey), _stream);
}
else
{
ComputeHash(txtMD5, MD5.Create(), _stream);
ComputeHash(txtRIPEMD160, RIPEMD160.Create(), _stream);
ComputeHash(txtSHA1, SHA1.Create(), _stream);
ComputeHash(txtSHA256, SHA256.Create(), _stream);
ComputeHash(txtSHA384, SHA384.Create(), _stream);
ComputeHash(txtSHA512, SHA512.Create(), _stream);
ComputeHash(txtCRC32, new CRC32(), _stream);
}
TestMatcher();
}
public void AddColumnInformationTestReverse()
{
OutputColumn target = new OutputColumn();
IDTSBufferManager100 bufferManager = new BufferManagerTestImpl();
IDTSOutput100 output = new OutputTestImpl();
IDTSInput100 input = new InputTestImpl();
IDTSOutputColumn100 outputColumn;
IDTSCustomProperty100 customProperty;
int outputColumnIndex = 0;
outputColumn = output.OutputColumnCollection.New();
customProperty = outputColumn.CustomPropertyCollection.New();
customProperty.Name = Utility.InputColumnLineagePropName;
customProperty.Value = "#1,#2,#3,#4,#5,#6";
customProperty = outputColumn.CustomPropertyCollection.New();
customProperty.Name = Utility.HashTypePropName;
customProperty.Value = MultipleHash.HashTypeEnumerator.RipeMD160;
target.AddColumnInformation(bufferManager, output, input, outputColumnIndex);
Assert.AreEqual(6, target.Count, "The number of items in the list");
Assert.AreEqual(1, target[0], "The first input");
Assert.AreEqual(2, target[1], "The second input");
Assert.AreEqual(3, target[2], "The third input");
Assert.AreEqual(4, target[3], "The forth input");
Assert.AreEqual(5, target[4], "The fifth input");
Assert.AreEqual(6, target[5], "The sixth input");
Assert.AreEqual(MultipleHash.HashTypeEnumerator.RipeMD160, target.HashType, "Hash");
Assert.AreEqual(RIPEMD160.Create().ToString(), target.HashObject.ToString(), "Hash Object");
}
private HashAlgorithm Algorithm()
{
switch (hash)
{
case (Hashes.MD5):
return(MD5.Create());
case (Hashes.RIPEMD160):
return(RIPEMD160.Create());
case (Hashes.SHA1):
return(SHA1.Create());
case (Hashes.SHA256):
return(SHA256.Create());
case (Hashes.SHA384):
return(SHA384.Create());
case (Hashes.SHA512):
return(SHA512.Create());
default:
return(MD5.Create());
}
}
public void TestP2SH_P2PKH()
{
//Create p2pkh
CryptoRSA rsa = new CryptoRSA(key, true);
Interpreter.Initialize();
//Create address
byte[] pubkeyhash;
using (var rid = RIPEMD160.Create())
using (var sha = SHA256.Create())
pubkeyhash = rid.ComputeHash(sha.ComputeHash(key.publicKey));
LockingScript ls = new LockingScript(BASE58.Encode(pubkeyhash));
UnlockingScript us = new UnlockingScript(rsa.Sign(transaction.Hash()), key.publicKey);
//Create p2sh and insert p2pkh in it
LockingScript ls1 = new LockingScript(ls);
UnlockingScript us1 = new UnlockingScript(ls, us);
us1.InsertScript(ls1);
Assert.AreEqual(EXECUTION_RESULT.SUCCESS, us1.Run(transaction), "Execution of P2SH script failed");
}
private void setHash()
{
switch (chooseHash)
{
case (Hashes.MD5):
hash = MD5.Create();
break;
case (Hashes.RIPEMD160):
hash = RIPEMD160.Create();
break;
case (Hashes.SHA1):
hash = SHA1.Create();
break;
case (Hashes.SHA256):
hash = SHA256.Create();
break;
case (Hashes.SHA384):
hash = SHA384.Create();
break;
case (Hashes.SHA512):
hash = SHA512.Create();
break;
}
}
private static String GetAddressFromPublicKey(byte[] scriptBytes, int publicKeyIndex, int keyLength, byte[] type)
{
var sha = SHA256.Create().ComputeHash(scriptBytes, publicKeyIndex, keyLength);
var ripe = RIPEMD160.Create().ComputeHash(sha);
return(GetAddressFromHash160(ripe, 0, BASE58PREFIX_PUBKEY_ADDRESS));
}
public static HashAlgorithm Create(string algorithmName)
{
switch (algorithmName.ToUpperInvariant())
{
case HashAlgorithmNames.MD5:
return(MD5.Create());
case HashAlgorithmNames.SHA1:
return(SHA1.Create());
case HashAlgorithmNames.SHA256:
return(SHA256.Create());
case HashAlgorithmNames.SHA384:
return(SHA384.Create());
case HashAlgorithmNames.SHA512:
return(SHA512.Create());
case HashAlgorithmNames.RIPEMD160:
return(RIPEMD160.Create());
}
return(null);
}
public Wallet(byte[] publicKey)
{
// Step 1: Allocate payload list
var payload = new List <byte>();
// Step 2: Append version
//payload.Add(version);
payload.AddRange(WalletVersion);
// Step 3: Create ripmd160(sha256(publicKey)) hash
var pub256Key = SHA256.Create().ComputeHash(publicKey);
var ripmd160 = RIPEMD160.Create().ComputeHash(pub256Key);
// Step 4: append hash to payload
payload.AddRange(ripmd160);
// Step 5: compute checksum of current payload
var checksum = Checksum(payload.ToArray());
// Step 6: append computed checksum to payload
payload.AddRange(checksum);
var address = payload.ToArray();
// Step 7: convert payload bytes to base58 format
Base58Address = Base58.Bitcoin.Encode(address);
}
/// <summary>
/// Get the <see cref="HashAlgorithm"/> associated to the <see cref="HashAlgorithmEnum"/>
/// </summary>
/// <param name="algorithm">Algorithm request</param>
/// <returns></returns>
static public HashAlgorithm GetAlgorithm(HashAlgorithmEnum algorithm)
{
switch (algorithm)
{
case HashAlgorithmEnum.MD5:
return(MD5.Create());
case HashAlgorithmEnum.SHA1:
return(SHA1.Create());
case HashAlgorithmEnum.SHA256:
return(SHA256.Create());
case HashAlgorithmEnum.SHA384:
return(SHA384.Create());
case HashAlgorithmEnum.SHA512:
return(SHA512.Create());
case HashAlgorithmEnum.RIPEMD160:
return(RIPEMD160.Create());
case HashAlgorithmEnum.KeyedHashAlgorithm:
return(KeyedHashAlgorithm.Create());
default:
return(SHA256.Create());
}
}
private string GetHash(SupportedHashAlgorithims hashType, string filePath)
{
switch (hashType)
{
case SupportedHashAlgorithims.MESSAGEDIGEST5:
return(MakeHashString(MD5.Create().ComputeHash(new FileStream(filePath, FileMode.Open))));
case SupportedHashAlgorithims.SECUREHASHALGORITHIM1:
return(MakeHashString(SHA1.Create().ComputeHash(new FileStream(filePath, FileMode.Open))));
case SupportedHashAlgorithims.SECUREHASHALGORITHIM256:
return(MakeHashString(SHA256.Create().ComputeHash(new FileStream(filePath, FileMode.Open))));
case SupportedHashAlgorithims.SECUREHASHALGORITHIM384:
return(MakeHashString(SHA384.Create().ComputeHash(new FileStream(filePath, FileMode.Open))));
case SupportedHashAlgorithims.SECUREHASHALGORITHIM512:
return(MakeHashString(SHA512.Create().ComputeHash(new FileStream(filePath, FileMode.Open))));
// TODO: Why do we need to do this?
#if !NETCOREAPP
case SupportedHashAlgorithims.RACEINTEGRITYPRIMITIVESEVALUATIONMESSAGEDIGEST:
return(MakeHashString(RIPEMD160.Create().ComputeHash(new FileStream(filePath, FileMode.Open))));
#endif
default:
return("");
}
}
private void btnGeraHashRIPEMD160_Click(object sender, EventArgs e)
{
txtHash.Text = "";
var hash = new TrataHash(RIPEMD160.Create());
txtHash.Text = hash.GerarHash(txtTexto.Text);
}
public void GenerateHash_RIPEMD160()
{
Hash h = new Hash(wellKnownAssembly);
byte[] result = h.GenerateHash(RIPEMD160.Create());
Assert.AreEqual("29-5A-21-11-BC-CA-1B-26-A2-46-F2-48-B4-61-96-1C-A5-2C-9A-9A", BitConverter.ToString(result));
}
public static byte[] Ripemd160(byte[] data)
{
using (RIPEMD160 hash = RIPEMD160.Create())
{
return(hash.ComputeHash(data));
}
}
public static string GetHash(this string input, HashType hashType)
{
byte[] inputBytes = input.ToByteArray();
switch (hashType)
{
case HashType.HMAC: return(Convert.ToBase64String(HMAC.Create().ComputeHash(inputBytes)));
case HashType.HMACMD5: return(Convert.ToBase64String(HMAC.Create().ComputeHash(inputBytes)));
case HashType.HMACSHA1: return(Convert.ToBase64String(HMAC.Create().ComputeHash(inputBytes)));
case HashType.HMACSHA256: return(Convert.ToBase64String(HMAC.Create().ComputeHash(inputBytes)));
case HashType.HMACSHA384: return(Convert.ToBase64String(HMAC.Create().ComputeHash(inputBytes)));
case HashType.HMACSHA512: return(Convert.ToBase64String(HMAC.Create().ComputeHash(inputBytes)));
case HashType.MACTripleDES: return(Convert.ToBase64String(KeyedHashAlgorithm.Create().ComputeHash(inputBytes)));
case HashType.MD5: return(Convert.ToBase64String(MD5.Create().ComputeHash(inputBytes)));
case HashType.RIPEMD160: return(Convert.ToBase64String(RIPEMD160.Create().ComputeHash(inputBytes)));
case HashType.SHA1: return(Convert.ToBase64String(SHA1.Create().ComputeHash(inputBytes)));
case HashType.SHA256: return(Convert.ToBase64String(SHA256.Create().ComputeHash(inputBytes)));
case HashType.SHA384: return(Convert.ToBase64String(SHA384.Create().ComputeHash(inputBytes)));
case HashType.SHA512: return(Convert.ToBase64String(SHA512.Create().ComputeHash(inputBytes)));
default: return(Convert.ToBase64String(inputBytes));
}
}
/// <summary>
/// Creates the hash algorithm by the given name.
/// </summary>
/// <returns>The hash algorithm.</returns>
/// <param name="name">Name of the has algorithm.</param>
public static HashAlgorithm CreateHashAlgorithm(string name)
{
name = name.ToLower();
if (name.Equals("sha1") || name.Equals("sha-1"))
{
return(SHA1.Create());
}
if (name.Equals("sha256") || name.Equals("sha-256"))
{
return(SHA256.Create());
}
if (name.Equals("sha384") || name.Equals("sha-384"))
{
return(SHA384.Create());
}
if (name.Equals("sha512") || name.Equals("sha-512"))
{
return(SHA512.Create());
}
if (name.Equals("md5"))
{
return(MD5.Create());
}
if (name.Equals("ripemd160") || name.Equals("ripemd"))
{
return(RIPEMD160.Create());
}
return(HashAlgorithm.Create());
}
private void bgwRIPEMD160_DoWork(object sender, DoWorkEventArgs e)
{
string filePath = e.Argument.ToString();
byte[] buffer;
int bytesRead;
long sizeOfFile, totalBytesToRead = 0;
using (Stream fileStream = File.OpenRead(filePath))
{
sizeOfFile = fileStream.Length;
using (HashAlgorithm ripemd160 = RIPEMD160.Create())
{
do
{
buffer = new byte[4096];
bytesRead = fileStream.Read(buffer, 0, buffer.Length);
totalBytesToRead += bytesRead;
ripemd160.TransformBlock(buffer, 0, bytesRead, null, 0);
bgwRIPEMD160.ReportProgress((int)((double)totalBytesToRead / sizeOfFile * 100));
} while (bytesRead != 0);
ripemd160.TransformFinalBlock(buffer, 0, 0);
e.Result = MakeRIPEMD160HashString(ripemd160.Hash);
}
}
}
/// <summary>
/// Transforms a file's bytes into an array of cryptographically strong data.
/// </summary>
/// <param name="path">The location of the file to hash.</param>
/// <param name="hash">The algorithm to be used for hashing.</param>
private byte[] GetFileHash(string path, HashType hash)
{
using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, (1024 * 1024)))
{
switch (hash)
{
case HashType.MD5:
return(MD5.Create().ComputeHash(file));
case HashType.RIPEMD160:
return(RIPEMD160.Create().ComputeHash(file));
case HashType.SHA1:
return(SHA1.Create().ComputeHash(file));
case HashType.SHA256:
return(SHA256.Create().ComputeHash(file));
case HashType.SHA384:
return(SHA384.Create().ComputeHash(file));
case HashType.SHA512:
return(SHA512.Create().ComputeHash(file));
default:
return(null);
}
}
}
static void Main(string[] args)
{
//--INPUT STRING
Console.Write("Input Text To encrypt : ");
string input = Console.ReadLine();
//--MD5 ALGORITHM
MD5 mD5 = MD5.Create();
PrintOutput(GetHashMethode(mD5, input), "MD5");
//--RIPEMD160 ALGORIHM
RIPEMD160 rIPEMD160 = RIPEMD160.Create();
PrintOutput(GetHashMethode(rIPEMD160, input), "RIPEMD160");
//--SHA1 ALGORITHM
SHA1 sHA1 = SHA1.Create();
PrintOutput(GetHashMethode(sHA1, input), "SHA1");
//--SHA256 ALGHORITHM
SHA256 sHA256 = SHA256.Create();
PrintOutput(GetHashMethode(sHA256, input), "SHA256");
//--SHA384 ALGORITHM
SHA384 sHA384 = SHA384.Create();
PrintOutput(GetHashMethode(sHA384, input), "SHA384");
//--SHA512 ALGORITHM
SHA512 sHA512 = SHA512.Create();
PrintOutput(GetHashMethode(sHA512, input), "SHA512");
}
/// <summary>
/// Transforms a string into a cryptographically strong hash.
/// </summary>
/// <param name="input">The string to be transformed.</param>
/// <param name="hash">The algorithm to used for hashing.</param>
private byte[] GetHash(string input, HashType hash)
{
byte[] inputBytes = Encoding.ASCII.GetBytes(input);
switch (hash)
{
case HashType.MD5:
return(MD5.Create().ComputeHash(inputBytes));
case HashType.RIPEMD160:
return(RIPEMD160.Create().ComputeHash(inputBytes));
case HashType.SHA1:
return(SHA1.Create().ComputeHash(inputBytes));
case HashType.SHA256:
return(SHA256.Create().ComputeHash(inputBytes));
case HashType.SHA384:
return(SHA384.Create().ComputeHash(inputBytes));
case HashType.SHA512:
return(SHA512.Create().ComputeHash(inputBytes));
default:
return(inputBytes);
}
}
public void RIPEMD160abc()
{
var ripemd160 = RIPEMD160.Create();
var result = ripemd160.ComputeHash("abc".ToByteArray());
Assert.AreEqual("8eb208f7e05d987a9b044a8e98c6b087f15a0bfc", result.ToHexString());
}
public static byte[] getHash(string password)
{
var r = RIPEMD160.Create();
var bfr = password.GetBytes().Concat(Salt).ToArray();
return(r.ComputeHash(bfr));
}
public void RIPEMD160FullAlphabet()
{
var ripemd160 = RIPEMD160.Create();
var result = ripemd160.ComputeHash("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".ToByteArray());
Assert.AreEqual("b0e20b6e3116640286ed3a87a5713079b21f5189", result.ToHexString());
}
public string ToPtsAddy()
{
var buffer = ToBuffer(true);
var firstHash = SHA256.Create().HashAndDispose(buffer);
buffer.Clear();
var secondHash = RIPEMD160.Create().HashAndDispose(firstHash);
firstHash.Clear();
var hash = new byte[] { 0x38 }.Concat(secondHash); // version 56(decimal)
secondHash.Clear();
var firstChecksum = SHA256.Create().HashAndDispose(hash);
var secondChecksum = SHA256.Create().HashAndDispose(firstChecksum);
firstChecksum.Clear();
var checksum = secondChecksum.Slice(0, 4);
secondChecksum.Clear();
buffer = hash.Concat(checksum);
checksum.Clear();
hash.Clear();
var result = Base58CheckEncoding.EncodePlain(buffer);
buffer.Clear();
return(result);
}