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); }