public string Hash(string valueToHash, string salt, bool saveSaltInResult, int bitLength)
{
var fullText = string.Concat(valueToHash, salt);
var data = Encoding.UTF8.GetBytes(fullText);
var sha3 = new Sha3Digest(bitLength);
var hashedBytes = new byte[sha3.GetDigestSize()];
var toHashAsBytes = Encoding.ASCII.GetBytes(valueToHash);
sha3.BlockUpdate(toHashAsBytes, 0, toHashAsBytes.Length);
sha3.DoFinal(hashedBytes, 0);
var asString = ByteArrayToString(hashedBytes);
var algorithm = 0;
if (bitLength == 512)
{
algorithm = (int)HashAlgorithm.SHA3_512;
}
else
{
throw new NotImplementedException($"Cannot find a HashAlgorithm for bit length: {bitLength}");
}
if (saveSaltInResult)
{
return(string.Format("[{0}]{1}{2}", algorithm, salt, asString));
}
else
{
return(string.Format("[{0}]{1}", algorithm, asString));
}
}
public async Task SecretProofTransactionTest()
{
var signer = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var secretHash = new byte[64];
var digest = new Sha3Digest(512);
digest.BlockUpdate("5D8BEBBE80D7EA3B0088E59308D8671099781429".FromHex(), 0, "5D8BEBBE80D7EA3B0088E59308D8671099781429".FromHex().Length);
digest.DoFinal(secretHash, 0);
var trans = SecretProofTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
0,
HashType.Types.SHA3_512,
secretHash.ToHexLower(),
"5D8BEBBE80D7EA3B0088E59308D8671099781429")
.SignWith(signer);
listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(signer.PublicKeyString,
NetworkType.Types.MIJIN_TEST)).Subscribe(e => Console.WriteLine(e.TransactionInfo.Hash));
await new TransactionHttp(host).Announce(trans);
var status = await listener.TransactionStatus(Address.CreateFromPublicKey(signer.PublicKeyString, NetworkType.Types.MIJIN_TEST)).Where(e => e.Hash == trans.Hash).Take(1);
Assert.AreEqual("Failure_Lock_Secret_Already_Used", status.Status);
}
private IDigest GetShaDigest()
{
IDigest shaDigest = null;
if (_shaBits == 1)
{
shaDigest = new Sha1Digest();
}
else if (_shaBits == 3)
{
shaDigest = new Sha3Digest();
}
else if (_shaBits == 224)
{
shaDigest = new Sha224Digest();
}
else if (_shaBits == 256)
{
shaDigest = new Sha256Digest();
}
else if (_shaBits == 384)
{
shaDigest = new Sha384Digest();
}
else
{
shaDigest = new Sha512Digest();
}
return(shaDigest);
}
public static byte[] ComputeSha3Digest(byte[] data, int bitLength)
{
var digest = new Sha3Digest(bitLength);
byte[] buffer = new byte[digest.GetDigestSize()];
digest.BlockUpdate(data, 0, data.Length);
digest.DoFinal(buffer, 0);
return(buffer);
}
public byte[] CalculateSha3Hash(byte[] value)
{
var digest = new Sha3Digest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(value, 0, value.Length);
digest.DoFinal(output, 0);
return(output);
}
public static byte[] ComputeSha3Hash(byte[] data)
{
var shaHash = new Sha3Digest();
shaHash.BlockUpdate(data, 0, data.Length);
byte[] hashedValue = new byte[shaHash.GetDigestSize()];
shaHash.DoFinal(hashedValue, 0);
return(hashedValue);
}
/// <summary>
/// Hash an array of bytes using Sha3 256 algorithm.
/// </summary>
/// <param name="bytes">The bytes.</param>
/// <returns>System.Byte[].</returns>
public static byte[] Sha3_256(byte[] bytes)
{
var temp = new byte[32];
var digest = new Sha3Digest(256);
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(temp, 0);
return(temp);
}
private string ExecuteHash()
{
IDigest hash;
switch (this.HashFunctionComboBox.Text)
{
case "Blake2b - 256 bit":
hash = new Blake2bDigest(256);
break;
case "Blake2b - 512 bit":
hash = new Blake2bDigest(512);
break;
case "SHA-1":
hash = new Sha1Digest();
break;
case "SHA-2 256 bit":
hash = new Sha256Digest();
break;
case "SHA-2 512 bit":
hash = new Sha512Digest();
break;
case "SHA-3 256 bit":
hash = new Sha3Digest(256);
break;
case "SHA-3 512 bit":
hash = new Sha3Digest(512);
break;
default:
hash = new Sha1Digest();
break;
}
byte[] result = new byte[hash.GetDigestSize()];
using (Stream source = File.OpenRead(this.LocationTextBox.Text))
{
int BytesRead;
while ((BytesRead = source.Read(this._Data, 0, this._Data.Length)) > 0)
{
hash.BlockUpdate(this._Data, 0, BytesRead);
}
}
hash.DoFinal(result, 0);
Array.Clear(this._Data, 0, this._Data.Length);
return(Entities.HashFunctionList.ByteArrayToHexString(result));
}
private Hash CalculateHash(byte[] bytes)
{
Sha3Digest digest = new Sha3Digest(256);
digest.BlockUpdate(bytes, 0, bytes.Length);
byte[] result = new byte[32];
digest.DoFinal(result, 0);
return(new Hash(result));
}
/// <summary>
/// Computes the SHA3 hash
/// </summary>
/// <param name="data"></param>
/// <param name="bitLength"></param>
/// <returns></returns>
private byte[] ComputeSHA3(byte[] data, int bitLength)
{
var digest = new Sha3Digest(bitLength);
digest.BlockUpdate(data, 0, data.Length);
var result = new byte[digest.GetDigestSize()];
digest.DoFinal(result, 0);
return(result);
}
public static Hash32 Digest(byte[] bytes)
{
var sha3 = new Sha3Digest();
sha3.BlockUpdate(bytes, 0, bytes.Length);
bytes = new byte[32];
sha3.DoFinal(bytes, 0);
return(new Hash32(bytes));
}
private static byte[] ComputeSha3Hash(this byte[] input, int bitLength)
{
var hashAlgo = new Sha3Digest(bitLength);
hashAlgo.BlockUpdate(input, 0, input.Length);
var output = new byte[bitLength / 8];
hashAlgo.DoFinal(output, 0);
return(output);
}
/// <summary>
/// Hash data with SHA3
/// </summary>
/// <param name="data">Data to hash</param>
/// <param name="bitLength">Size in bits</param>
/// <returns>Hash</returns>
public static byte[] Hash(byte[] data, int bitLength = 512)
{
byte[] result = new byte[bitLength / 8];
Sha3Digest sha3 = new Sha3Digest(bitLength);
sha3.BlockUpdate(data, 0, data.Length);
sha3.DoFinal(result, 0);
return(result);
}
protected static byte[] ComputeHash(byte[] bytes, int bits)
{
var digest = new Sha3Digest(bits);
var output = new byte[digest.GetDigestSize()];
byte[] message = bytes ?? new byte[0];
digest.BlockUpdate(message, 0, message.Length);
digest.DoFinal(output, 0);
return(output);
}
private Hash CalculateHash()
{
Sha3Digest digest = new Sha3Digest(256);
byte[] bytes = BlockHeaderEncoder.Instance.Encode(this);
digest.BlockUpdate(bytes, 0, bytes.Length);
byte[] result = new byte[32];
digest.DoFinal(result, 0);
return(new Hash(result));
}
private static byte[] Sha256(string data)
{
var input = Encoding.UTF8.GetBytes(data);
var digest = new Sha3Digest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(input, 0, input.Length);
digest.DoFinal(output, 0);
return(output);
}
/// <summary>
/// Computes the SHA3 hash value for the specified byte array.
/// </summary>
/// <param name="bitLength">Output size of hash in bits.</param>
/// <param name="buffer">The input to compute the hash code for.</param>
/// <returns>The computed hash code.</returns>
public static byte[] ComputeHash(int bitLength, byte[] buffer)
{
var hashAlgorithm = new Sha3Digest(bitLength);
hashAlgorithm.BlockUpdate(buffer, 0, buffer.Length);
var computedHashCode = new byte[bitLength / 8];
hashAlgorithm.DoFinal(computedHashCode, 0);
return(computedHashCode);
}
void TwoFish(string TextPlain, string Password, byte[] Salt, string Prefix = "")
{
Sha3Digest Sha3Digest = new Sha3Digest((int)KeySizes.F256);
Pkcs5S2ParametersGenerator gen = new Pkcs5S2ParametersGenerator(Sha3Digest);
gen.Init(Encoding.UTF8.GetBytes(Password), BCEngines.PreFixSaltBytes(Salt, Prefix), Constants.NUM_ITERATOR);
KeyParameter = (KeyParameter)gen.GenerateDerivedParameters(BCEngines.TwofishEngine.AlgorithmName, (int)KeySizes.F256);
SetPadding(new Pkcs7Padding());
SetBlockCipher(BCEngines.TwofishEngine);
SetEncoding(Encoding.UTF8);
}
/// <summary>
/// SAH3 hash of [data].
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static byte[] Sha3(byte[] data)
{
Guard.NotNull(data, nameof(data));
Guard.NotLessThanOrEqualTo(data.Length, 0, nameof(data));
var digest = new Sha3Digest(512);
digest.BlockUpdate(data, 0, data.Length);
var result = new byte[64]; // 512 / 8 = 64
digest.DoFinal(result, 0);
return(result);
}
public static string Decrypt2F(string TextEncripted, string Password, byte[] Salt)
{
Sha3Digest Sha3Digest = new Sha3Digest();
Pkcs5S2ParametersGenerator gen = new Pkcs5S2ParametersGenerator(Sha3Digest);
gen.Init(Encoding.UTF8.GetBytes(Password), Salt, 1000);
KeyParameter param = (KeyParameter)gen.GenerateDerivedParameters(new TwofishEngine().AlgorithmName, 256);
BC2F bcEngine = new BC2F(new TwofishEngine(), Encoding.UTF8);
bcEngine.SetPadding(new Pkcs7Padding());
return(bcEngine.Decrypt(TextEncripted, param));
}
public static ExternalAddress Create(PublicKey publicKey)
{
byte[] bytes = publicKey.Binary.Skip(1).ToArray();
var sha3 = new Sha3Digest();
sha3.BlockUpdate(bytes, 0, bytes.Length);
bytes = new byte[32];
sha3.DoFinal(bytes, 0);
return(new ExternalAddress(bytes.Skip(12)));
}
//This class handles the mining of the block based on the transactions in a block + datetime stamp (utc) + previous hash
public Hash CalculateHash(Hash _parentHash, IList <BlockTransaction> _unconfirmedTransactions, DateTime _dateTimeStampBlock)
{
byte[] Input = BlockMiningManager.GenerateBytes(_parentHash != null? Convert.ToString(_parentHash.GetHashCode()):"", _dateTimeStampBlock.ToString(), Convert.ToString(_unconfirmedTransactions.GetHashCode()));
//Design decision, vary difficulty by using PBKDF2 or maintain SHA3 256...later to be decided
Sha3Digest digest = new Sha3Digest(256);
digest.BlockUpdate(Input, 0, Input.Length);
byte[] result = new byte[32];
digest.DoFinal(result, 0);
return(new Hash(result));
}
public static byte[] GetAddressHash(byte[] publicKey)
{
var digest = new Sha3Digest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(publicKey, 0, publicKey.Length);
digest.DoFinal(output, 0);
var result = new byte[20];
Array.Copy(output, output.Length - 20, result, 0, 20);
return(result);
}
/// <summary>
/// Generates an in based on parentId and name
/// </summary>
/// <param name="parentId">The 64 bit id of the parent namespace.</param>
/// <param name="name">The name of the bottom most namespace or mosaic.</param>
/// <returns type="long">The 64 bit id.</returns>
internal static ulong GenerateId(ulong parentId, string name)
{
var p = BitConverter.GetBytes(parentId);
var n = Encoding.UTF8.GetBytes(name);
var hash = new Sha3Digest(256);
hash.BlockUpdate(p.Concat(n).ToArray(), 0, p.Length + n.Length);
var result = new byte[32];
hash.DoFinal(result, 0);
return((ulong)BitConverter.ToInt64(result, 0));
}
public static ulong GenerateNsId(ulong parentId, string name)
{
var pBytes = BitConverter.GetBytes(parentId);
var nBytes = Encoding.UTF8.GetBytes(name);
var hash = new Sha3Digest(256);
hash.BlockUpdate(pBytes.Concat(nBytes).ToArray(), 0, pBytes.Length + nBytes.Length);
var result = new byte[32];
hash.DoFinal(result, 0);
return((ulong)BitConverter.ToInt64(result, 0) | 0x8000000000000000);
}
/// <summary>
/// Hashers the specified payload.
/// </summary>
/// <param name="payload">The payload.</param>
/// <returns>The transaction hash.</returns>
internal static byte[] Hasher(byte[] payload)
{
var sigAndKey = payload.Take(4, 32)
.Concat(
payload.Take(4 + 64, payload.Length - (4 + 64))
).ToArray();
var hash = new byte[32];
var sha3Hasher = new Sha3Digest(256);
sha3Hasher.BlockUpdate(sigAndKey, 0, sigAndKey.Length);
sha3Hasher.DoFinal(hash, 0);
return(hash);
}
private string Hash(string password)
{
Sha3Digest hashAlgorithm = new Sha3Digest(512);
// Choose correct encoding based on your usecase
byte[] input = Encoding.UTF8.GetBytes(password);
hashAlgorithm.BlockUpdate(input, 0, input.Length);
byte[] result = new byte[64]; // 512 / 8 = 64
hashAlgorithm.DoFinal(result, 0);
string hashString = BitConverter.ToString(result);
return(hashString.Replace("-", "").ToLowerInvariant());
}
public static byte[] SHA3_512(byte[] bytes)
{
if (!SHA3_512Hashers.TryPop(out var hasher))
{
hasher = new Sha3Digest(512);
}
try {
var result = new byte[hasher.GetDigestSize()];
hasher.BlockUpdate(bytes, 0, bytes.Length);
hasher.DoFinal(result, 0);
hasher.Reset();
return(result);
} finally {
SHA3_512Hashers.Push(hasher);
}
}
private static byte[] CalculateChecksum(byte[] pubkey)
{
// TORv3 CHECKSUM = H(".onion checksum" | PUBKEY | VERSION)[:2]
var prefix = Encoders.ASCII.DecodeData(".onion checksum");
var hasher = new Sha3Digest(256);
hasher.BlockUpdate(prefix, 0, prefix.Length);
hasher.BlockUpdate(pubkey, 0, pubkey.Length);
hasher.Update((byte)3);
var fullChecksum = new byte[hasher.GetByteLength()];
hasher.DoFinal(fullChecksum, 0);
return(fullChecksum.SafeSubarray(0, TORV3_ADDR_CHECKSUM_LEN));
}
/*
* Copied from nem2-sdk Ed25519.derive_key
*/
private static byte[] GetSecretKey(byte[] salt, string privateKey, string publicKey)
{
var shared = new byte[32];
var longKeyHash = new byte[64];
var shortKeyHash = new byte[32];
// Array.Reverse(secretKey);
// compute Sha3(512) hash of secret key (as in prepareForScalarMultiply)
var digestSha3 = new Sha3Digest(512);
digestSha3.BlockUpdate(privateKey.FromHex(), 0, 32);
digestSha3.DoFinal(longKeyHash, 0);
longKeyHash[0] &= 248;
longKeyHash[31] &= 127;
longKeyHash[31] |= 64;
Array.Copy(longKeyHash, 0, shortKeyHash, 0, 32);
ScalarOperationClamp(shortKeyHash, 0);
var p = new[] { new long[16], new long[16], new long[16], new long[16] };
var q = new[] { new long[16], new long[16], new long[16], new long[16] };
TweetNaCl.Unpackneg(q, publicKey.FromHex()); // returning -1 invalid signature
TweetNaCl.Scalarmult(p, q, shortKeyHash, 0);
TweetNaCl.Pack(shared, p);
// for some reason the most significant bit of the last byte needs to be flipped.
// doesnt seem to be any corrosponding action in nano/nem.core, so this may be an issue in one of the above 3 functions. i have no idea.
shared[31] ^= (1 << 7);
// salt
for (var i = 0; i < salt.Length; i++)
{
shared[i] ^= salt[i];
}
// hash salted shared key
var digestSha3Two = new Sha3Digest(256);
digestSha3Two.BlockUpdate(shared, 0, 32);
digestSha3Two.DoFinal(shared, 0);
return(shared);
}
