public byte[] CalculateKeccakHash(byte[] value)
{
var digest = new KeccakDigest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(value, 0, value.Length);
digest.DoFinal(output, 0);
return(output);
}
/// <summary>
/// Hashes the specified payload.
/// </summary>
/// <param name="payload">The payload.</param>
/// <returns>The transaction hash.</returns>
internal static byte[] Hasher(byte[] payload)
{
var hash = new byte[32];
var sha3Hasher = new KeccakDigest(256);
sha3Hasher.BlockUpdate(payload, 0, payload.Length);
sha3Hasher.DoFinal(hash, 0);
return(hash);
}
public static byte[] SHA3(this byte[] data)
{
KeccakDigest digest = new KeccakDigest(256);
byte[] output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(data, 0, data.Length);
digest.DoFinal(output, 0);
return(output);
}
public string CalculateHash(string value)
{
var digest = new KeccakDigest(256);
var output = new byte[digest.GetDigestSize()];
var input = Encoding.UTF8.GetBytes(value);
digest.BlockUpdate(input, 0, input.Length);
digest.DoFinal(output, 0);
return(output.ToHex());
}
public static byte[] Keccac256(byte[] data)
{
KeccakDigest k = new KeccakDigest(256);
k.BlockUpdate(data, 0, data.Length);
var hash = new byte[32];
k.DoFinal(hash, 0);
return(hash);
}
/// <summary>
/// Keccak256 hashing algorithm
/// </summary>
/// <param name="StringIn"></param>
/// <returns></returns>
public static string Keccak256HexHashString(string StringIn)
{
var sha3 = new KeccakDigest(256);
byte[] hash = new byte[sha3.GetDigestSize()];
byte[] value = Encoding.Default.GetBytes(StringIn);
sha3.BlockUpdate(value, 0, value.Length);
sha3.DoFinal(hash, 0);
return(ToHex(hash, false));
}
/// <summary>
/// Generates a SHA-3 hash of <paramref name="value"/>.
/// </summary>
/// <param name="value">The data to hash.</param>
/// <returns>The hashed result.</returns>
public static byte[] Sha3Keccack(this byte[] value)
{
var digest = new KeccakDigest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(value, 0, value.Length);
digest.DoFinal(output, 0);
return(output);
}
public static byte[] Hash(byte[] bytes, int bitLength)
{
var digest = new KeccakDigest(bitLength);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(output, 0);
return(output);
}
protected static byte[] ComputeHash(byte[] bytes, int bits)
{
var digest = new KeccakDigest(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);
}
/// <summary>
/// Returns message hash
/// </summary>
public static byte[] Keccak256(byte[] message, int offset, int size)
{
var kecc = new KeccakDigest(256);
kecc.BlockUpdate(message, offset, size);
var output = new byte[256];
kecc.DoFinal(output, 0);
return(output);
}
public static byte[] Keccak256Helper(byte[] _input)
{
KeccakDigest Kec256 = new KeccakDigest(256);
Kec256.Reset();
byte[] resultHashedKec256 = new byte[32];
Kec256.BlockUpdate(_input, 0, _input.Length);
Kec256.DoFinal(resultHashedKec256, 0);
return(resultHashedKec256);
}
public static byte[] Keccak256(byte[] data, int offset, int length)
{
byte[] buffer = new byte[32];
var keccakDigest = new KeccakDigest(256);
keccakDigest.BlockUpdate(data, offset, length);
keccakDigest.DoFinal(buffer, 0);
return(buffer);
}
private static byte[] DeriveAddress(PublicKey key)
{
byte[] hashPayload = key.Format(false).Skip(1).ToArray();
var digest = new KeccakDigest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(hashPayload, 0, hashPayload.Length);
digest.DoFinal(output, 0);
return(output.Skip(output.Length - 20).ToArray());
}
public static byte[] KeccakBytes(this IEnumerable <byte> message)
{
var bytes = message as byte[] ?? message.ToArray();
var digest = new KeccakDigest(256);
digest.BlockUpdate(bytes, 0, bytes.Length);
var output = new byte[32];
digest.DoFinal(output, 0);
return(output);
}
/// <summary>
/// Produces a <see cref="PrivateKeyAccountClient"/> from a given <see cref="SecureString"/> of any size.
/// </summary>
/// <remarks>
/// Takes a SecureString, hashes with Sha3 and converts the produced bytes to a 64 char hex string. The <see cref="StringUtils"/> class contains methods to convert to or from <see cref="SecureString"/>.
/// </remarks>
/// <param name="data">The data to convert to a private key.</param>
/// <returns>A <see cref="PrivateKeyAccountClient"/> that can be used to initiate transactions.</returns>
public PrivateKeyAccountClient FromNewDataPrivateKey(SecureString data)
{
var digestSha3 = new KeccakDigest(256);
var dataBytes = Encoding.Default.GetBytes(StringUtils.ConvertToUnsecureString(data));
var pkBytes = new byte[32];
digestSha3.BlockUpdate(dataBytes, 0, 32);
digestSha3.DoFinal(pkBytes, 0);
var sk = StringUtils.ToSecureString(CryptoBytes.ToHexStringLower(pkBytes));
return(FromPrivateKey(new PrivateKey(sk)));
}
/// <summary>
/// Gets the SHA3 digest from the specified data.
/// </summary>
/// <param name="data">The data.</param>
/// <returns>The digest string.</returns>
public static string GetSha3(MemoryStream data)
{
var digest = new KeccakDigest();
digest.BlockUpdate(data.ToArray(), 0, (int)data.Length);
var result = new byte[digest.GetDigestSize()];
digest.DoFinal(result, 0);
return(BitConverter.ToString(result).Replace("-", ""));
}
// Original crypto_sign_open, for reference only
/*public static int crypto_sign_open(
* byte[] m, out int mlen,
* byte[] sm, int smlen,
* byte[] pk)
* {
* byte[] h = new byte[64];
* byte[] checkr = new byte[32];
* GroupElementP3 A;
* GroupElementP2 R;
* int i;
*
* mlen = -1;
* if (smlen < 64) return -1;
* if ((sm[63] & 224) != 0) return -1;
* if (GroupOperations.ge_frombytes_negate_vartime(out A, pk, 0) != 0) return -1;
*
* for (i = 0; i < smlen; ++i) m[i] = sm[i];
* for (i = 0; i < 32; ++i) m[32 + i] = pk[i];
* Sha512BclWrapper.crypto_hash_sha512(h, m, 0, smlen);
* ScalarOperations.sc_reduce(h);
*
* var sm32 = new byte[32];
* Array.Copy(sm, 32, sm32, 0, 32);
* GroupOperations.ge_double_scalarmult_vartime(out R, h, ref A, sm32);
* GroupOperations.ge_tobytes(checkr, 0, ref R);
* if (Helpers.crypto_verify_32(checkr, sm) != 0)
* {
* for (i = 0; i < smlen; ++i)
* m[i] = 0;
* return -1;
* }
*
* for (i = 0; i < smlen - 64; ++i)
* m[i] = sm[64 + i];
* for (i = smlen - 64; i < smlen; ++i)
* m[i] = 0;
* mlen = smlen - 64;
* return 0;
* }*/
public static bool crypto_sign_verify(
byte[] sig, int sigoffset,
byte[] m, int moffset, int mlen,
byte[] pk, int pkoffset)
{
byte[] checkr = new byte[32];
GroupElementP3 A;
GroupElementP2 R;
if ((sig[sigoffset + 63] & 224) != 0)
{
return(false);
}
if (GroupOperations.ge_frombytes_negate_vartime(out A, pk, pkoffset) != 0)
{
return(false);
}
var hash = new KeccakDigest(512);
hash.BlockUpdate(sig, sigoffset, 32);
hash.BlockUpdate(pk, pkoffset, 32);
hash.BlockUpdate(m, moffset, mlen);
var b = new byte[64];
hash.DoFinal(b, 0);
ScalarOperations.sc_reduce(b);
var sm32 = new byte[32];//todo: remove allocation
Array.Copy(sig, sigoffset + 32, sm32, 0, 32);
GroupOperations.ge_double_scalarmult_vartime(out R, b, ref A, sm32);
GroupOperations.ge_tobytes(checkr, 0, ref R);
var result = CryptoBytes.ConstantTimeEquals(checkr, 0, sig, sigoffset, 32);
CryptoBytes.Wipe(b);
CryptoBytes.Wipe(checkr);
return(result);
}
private byte[] CalculateHash(byte[] data)
{
var cloner = new byte[data.Length];
Array.Copy(data, cloner, data.Length);
var hasher = new KeccakDigest(256);
hasher.BlockUpdate(cloner, 0, cloner.Length);
var output = new byte[hasher.GetDigestSize()];
hasher.DoFinal(output, 0);
return(output);
}
/// <summary>
///
/// </summary>
/// <param name="trits"></param>
/// <param name="offset"></param>
/// <param name="length"></param>
/// <returns></returns>
public override ICurl Absorb(sbyte[] trits, int offset, int length)
{
if (length % 243 != 0)
{
throw new IllegalStateException("Illegal length: " + length);
}
do
{
Array.Copy(trits, offset, _tritState, 0, HASH_LENGTH);
//convert to bits
_tritState[HASH_LENGTH - 1] = 0;
FixedBigIntConverter.FromTritsToBytes(_tritState, _byteState);
//run keccak
_keccak.BlockUpdate(_byteState, 0, _byteState.Length);
offset += HASH_LENGTH;
} while ((length -= HASH_LENGTH) > 0);
return(this);
}
/// <summary>
/// Create an Address from a given public key and network type.
/// </summary>
/// <param name="publicKey">The public key.</param>
/// <param name="networkType">The network type</param>
/// <returns>Address.</returns>
public Address(string publicKey, NetworkType.Types networkType)
{
// step 1) sha-3(256) public key
var digestSha3 = new KeccakDigest(256);
var stepOne = new byte[Constants.Key];
digestSha3.BlockUpdate(publicKey.FromHex(), 0, Constants.Key);
digestSha3.DoFinal(stepOne, 0);
// step 2) perform ripemd160 on previous step
var digestRipeMd160 = new RipeMD160Digest();
var stepTwo = new byte[Constants.Ripemd160];
digestRipeMd160.BlockUpdate(stepOne, 0, Constants.Key);
digestRipeMd160.DoFinal(stepTwo, 0);
// step3) prepend network byte
var stepThree = new[] { networkType.GetNetwork() }.Concat(stepTwo).ToArray();
// step 4) perform sha3 on previous step
var stepFour = new byte[Constants.Key];
digestSha3.BlockUpdate(stepThree, 0, Constants.Ripemd160 + 1);
digestSha3.DoFinal(stepFour, 0);
// step 5) retrieve checksum
var stepFive = new byte[Constants.Checksum];
Array.Copy(stepFour, 0, stepFive, 0, Constants.Checksum);
// step 6) append stepFive to resulst of stepThree
var stepSix = new byte[Constants.AddressDecoded];
Array.Copy(stepThree, 0, stepSix, 0, Constants.Ripemd160 + 1);
Array.Copy(stepFive, 0, stepSix, Constants.Ripemd160 + 1, Constants.Checksum);
// step 7) return base 32 encode address byte array
Initialize(stepSix.ToBase32String());
}
public static byte[] Sha3(this byte[] value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var digest = new KeccakDigest(256);
var output = new byte[digest.GetDigestSize()];
digest.BlockUpdate(value, 0, value.Length);
digest.DoFinal(output, 0);
return(output);
}
public static void SetSecrets(EncryptionHandshake handshake, HandshakeRole handshakeRole)
{
byte[] ephemeralSharedSecret = Proxy.EcdhSerialized(handshake.RemoteEphemeralPublicKey.Bytes, handshake.EphemeralPrivateKey.KeyBytes);
byte[] nonceHash = Keccak.Compute(Bytes.Concat(handshake.RecipientNonce, handshake.InitiatorNonce)).Bytes;
byte[] sharedSecret = Keccak.Compute(Bytes.Concat(ephemeralSharedSecret, nonceHash)).Bytes;
byte[] token = Keccak.Compute(sharedSecret).Bytes;
byte[] aesSecret = Keccak.Compute(Bytes.Concat(ephemeralSharedSecret, sharedSecret)).Bytes;
Array.Clear(sharedSecret, 0, sharedSecret.Length); // TODO: it was passed in the concat for Keccak so not good enough
byte[] macSecret = Keccak.Compute(Bytes.Concat(ephemeralSharedSecret, aesSecret)).Bytes;
Array.Clear(ephemeralSharedSecret, 0, ephemeralSharedSecret.Length); // TODO: it was passed in the concat for Keccak so not good enough
handshake.Secrets = new EncryptionSecrets();
handshake.Secrets.Token = token;
handshake.Secrets.AesSecret = aesSecret;
handshake.Secrets.MacSecret = macSecret;
KeccakDigest mac1 = new KeccakDigest(MacBitsSize);
mac1.BlockUpdate(macSecret.Xor(handshake.RecipientNonce), 0, macSecret.Length);
mac1.BlockUpdate(handshake.AuthPacket.Data, 0, handshake.AuthPacket.Data.Length);
KeccakDigest mac2 = new KeccakDigest(MacBitsSize);
mac2.BlockUpdate(macSecret.Xor(handshake.InitiatorNonce), 0, macSecret.Length);
mac2.BlockUpdate(handshake.AckPacket.Data, 0, handshake.AckPacket.Data.Length);
if (handshakeRole == HandshakeRole.Initiator)
{
handshake.Secrets.EgressMac = mac1;
handshake.Secrets.IngressMac = mac2;
}
else
{
handshake.Secrets.EgressMac = mac2;
handshake.Secrets.IngressMac = mac1;
}
}
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="trits"></param>
/// <param name="offset"></param>
/// <param name="length"></param>
/// <returns></returns>
public override void Absorb(int[] trits, int offset, int length)
{
if (length % 243 != 0)
{
throw new IllegalStateException("Illegal length: " + length);
}
do
{
//copy trits[offset:offset+length]
Array.Copy(trits, offset, _tritState, 0, HashLength);
//convert to bits
_tritState[HashLength - 1] = 0;
FixedBigIntConverter.FromTritsToBytes(_tritState, _byteState);
//BigIntConverter.BytesFromBigInt(
// BigIntConverter.BigIntFromTrits(_tritState, 0, HashLength),
// _byteState, 0, ByteHashLength);
//run keccak
_keccak.BlockUpdate(_byteState, 0, _byteState.Length);
offset += HashLength;
} while ((length -= HashLength) > 0);
}
public static byte[] GenerateMac(byte[] derivekey, byte[] ciphertext)
{
int size = (int)(derivekey.Length * 0.5) + ciphertext.Length;
byte[] input = new byte[size];
Array.Copy(derivekey, 16, input, 0, 16);
Array.Copy(ciphertext, 0, input, 16, ciphertext.Length);
var digest = new KeccakDigest(256);
var mac = new byte[digest.GetDigestSize()];
digest.BlockUpdate(input, 0, input.Length);
digest.DoFinal(mac, 0);
return(mac);
}
public void CheckMac(byte[] input, int offset, int length, bool isHeader)
{
if (isHeader)
{
UpdateMac(_ingressMac, input, offset, input, offset + length, false); // TODO: confirm header is seed
}
else
{
_ingressMac.BlockUpdate(input, offset, length);
// frame-mac: right128 of egress-mac.update(aes(mac-secret,egress-mac) ^ right128(egress-mac.update(frame-ciphertext).digest))
byte[] buffer = new byte[_ingressMac.GetDigestSize()];
DoFinalNoReset(_ingressMac, buffer, 0); // frame MAC seed
UpdateMac(_ingressMac, buffer, 0, input, offset + length, false);
}
}
public void DJB_Ed25519_Keccak512()
{
byte[] data = TEST;
var digest = new KeccakDigest(512);
var m = new byte[digest.OutputSize];
digest.BlockUpdate(data, 0, data.Length);
digest.DoFinal(m, 0);
ECKeypair keypair = KeypairFactory.GenerateECKeypair(DjbCurve.Ed25519.ToString());
byte[] sig = Ed25519.Sign(m, keypair.EncodedPrivateKey);
bool good = Ed25519.Verify(sig, m, keypair.EncodedPublicKey);
Assert.IsTrue(good);
}
public static void key_derive(byte[] shared, byte[] salt, byte[] secretKey, byte[] pubkey)
{
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 KeccakDigest(512);
digestSha3.BlockUpdate(secretKey, 0, 32);
digestSha3.DoFinal(longKeyHash, 0);
longKeyHash[0] &= 248;
longKeyHash[31] &= 127;
longKeyHash[31] |= 64;
Array.Copy(longKeyHash, 0, shortKeyHash, 0, 32);
ScalarOperations.sc_clamp(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.TweetNaCl.Unpackneg(q, pubkey); // returning -1 invalid signature
TweetNaCl.TweetNaCl.Scalarmult(p, q, shortKeyHash, 0);
TweetNaCl.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 KeccakDigest(256);
digestSha3Two.BlockUpdate(shared, 0, 32);
digestSha3Two.DoFinal(shared, 0);
}
/// <summary>
/// adapted from ethereumJ
/// </summary>
private byte[] UpdateMac(KeccakDigest mac, byte[] seed, int offset, byte[] output, int outOffset, bool egress)
{
byte[] aesBlock = new byte[mac.GetDigestSize()];
DoFinalNoReset(mac, aesBlock, 0);
// TODO: check if need to make a new one each time
MakeMacCipher().ProcessBlock(aesBlock, 0, aesBlock, 0);
// Note that although the mac digest size is 32 bytes, we only use 16 bytes in the computation
int length = 16;
for (int i = 0; i < length; i++)
{
aesBlock[i] ^= seed[i + offset];
}
mac.BlockUpdate(aesBlock, 0, length);
byte[] result = new byte[mac.GetDigestSize()];
DoFinalNoReset(mac, result, 0);
if (egress)
{
Array.Copy(result, 0, output, outOffset, length);
}
else
{
bool isMacSame = true;
for (int i = 0; i < length; i++)
{
if (output[i + outOffset] != result[i])
{
isMacSame = false;
break;
}
}
if (!isMacSame)
{
throw new IOException($"MAC mismatch from {_remoteNodeId}");
}
}
return(result);
}
public static PrivateKey Create()
{
var ng = RandomNumberGenerator.Create();
var bytes = new byte[2048];
ng.GetNonZeroBytes(bytes);
var digestSha3 = new KeccakDigest(256);
var stepOne = new byte[32];
digestSha3.BlockUpdate(bytes, 0, 32);
digestSha3.DoFinal(stepOne, 0);
var pk = new PrivateKey(StringUtils.ToSecureString(CryptoBytes.ToHexStringLower(stepOne)));
bytes = null;
stepOne = null;
return(pk);
}
public static EncryptionSecrets BuildSecretsWithSameIngressAndEgress()
{
EncryptionSecrets secrets = new EncryptionSecrets();
secrets.AesSecret = AesSecret;
secrets.MacSecret = MacSecret;
byte[] bytes = AesSecret.Xor(MacSecret);
KeccakDigest egressMac = new KeccakDigest(256);
egressMac.BlockUpdate(bytes, 0, 32);
secrets.EgressMac = egressMac;
KeccakDigest ingressMac = new KeccakDigest(256);
ingressMac.BlockUpdate(bytes, 0, 32);
secrets.IngressMac = ingressMac;
return(secrets);
}
