public FrameMacProcessor(PublicKey remoteNodeId, EncryptionSecrets secrets)
{
_remoteNodeId = remoteNodeId;
_macSecret = secrets.MacSecret;
_egressMac = secrets.EgressMac;
_egressMacCopy = (KeccakDigest)_egressMac.Copy();
_ingressMac = secrets.IngressMac;
_ingressMacCopy = (KeccakDigest)_ingressMac.Copy();
_aesEngine = MakeMacCipher();
_checkMacBuffer = new byte[_ingressMac.GetDigestSize()];
_addMacBuffer = new byte[_ingressMac.GetDigestSize()];
_ingressAesBlockBuffer = new byte[_ingressMac.GetDigestSize()];
_egressAesBlockBuffer = new byte[_ingressMac.GetDigestSize()];
}
static public BigInteger Mine(string challenge, BigInteger difficulty)
{
Byte[] b = new Byte[8];
var sha3 = new KeccakDigest(512);
var rnd = new Random(0);
rnd.NextBytes(b);
b = b.Reverse().Concat(new byte[] { 0x0 }).ToArray();
var nonce = new BigInteger(b);
var challengeBI = BigInteger.Parse(challenge, NumberStyles.AllowHexSpecifier);
while (true)
{
byte[] hashb = new byte[sha3.GetDigestSize()];
byte[] value = challengeBI.ToByteArray().Reverse().Concat(nonce.ToByteArray().Reverse()).ToArray();
sha3.BlockUpdate(value, 0, value.Length);
sha3.DoFinal(hashb, 0);
hashb = hashb.Reverse().Concat(new byte[] { 0x0 }).ToArray();
var v = new BigInteger(hashb);
if (v.CompareTo(difficulty) < 0)
{
break;
}
nonce = (BigInteger.Add(nonce, BigInteger.One)) % ((new BigInteger(2)) << 64);
}
return(nonce);
}
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>
/// 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 byte[] HashKeccak256(byte[] src)
{
KeccakDigest sha = new KeccakDigest(256);
sha.BlockUpdate(src, 0, src.Length);
byte[] output = new byte[sha.GetDigestSize()];
sha.DoFinal(output, 0);
return(output);
}
/// <summary>
/// Do hash
/// </summary>
/// <param name="data">Data</param>
byte[] CalculateHash(byte[] data)
{
KeccakDigest digest = new KeccakDigest(256);
byte[] raw = new byte[digest.GetDigestSize()];
digest.BlockUpdate(data, 0, data.Length);
digest.DoFinal(raw, 0);
return(raw);
}
public void TestKeccak()
{
byte[] source = Encoding.ASCII.GetBytes(
"asdçflkjasçfjaçrlgjaçorigjkljbçladkfjgsaºperouiwa89tuhyjkvsldkfjçaoigfjsadfjkhsdkgjhdlkgjhdkfjbnsdflçkgsriaugfukasyfgskaruyfgsaekufygvsanfbvsdj,fhgwukaygsja,fvkusayfguwayfgsnvfuksaygfkuybhsngfukayeghsmafbsjkfgwlauifgjkshfbilçehrkluayh");
var keccak128Test = new KeccakDigest(128);
var keccak224Test = new KeccakDigest(224);
var keccak256Test = new KeccakDigest(256);
var keccak288Test = new KeccakDigest(288);
var keccak384Test = new KeccakDigest(384);
var keccak512Test = new KeccakDigest(512);
for (int i = 0; i < 10000; i++)
{
//can't find any ground truth for this one, https://8gwifi.org/MessageDigest.jsp is the only one but when comparing to other site's results for other keccaks it doesnt match up with them
/*var output1 = new byte[keccak128Test.GetDigestSize()];
* keccak128Test.BlockUpdate(source, 0, source.Length);
* keccak128Test.DoFinal(output1, 0);
* var target1 = Base16.Decode("a896124a35603f3766d9d41dade89f9b");*/
var output2 = new byte[keccak224Test.GetDigestSize()];
keccak224Test.BlockUpdate(source, 0, source.Length);
keccak224Test.DoFinal(output2, 0);
var target2 = Base16.Decode("3c8aa5706aabc26dee19b466e77f8947f801762ca64316fdf3a2434a"); //https://emn178.github.io/online-tools/keccak_224.html
var output3 = new byte[keccak256Test.GetDigestSize()];
keccak256Test.BlockUpdate(source, 0, source.Length);
keccak256Test.DoFinal(output3, 0);
var target3 = Base16.Decode("09D3FA337D33E1BEB3C3D560D93F5FB57C66BC3E044127816F42494FA4947A92"); //https://asecuritysite.com/encryption/sha3
//can't find any ground truth for this one, https://8gwifi.org/MessageDigest.jsp is the only one but when comparing to other site's results for other keccaks it doesnt match up with them
/*var output4 = new byte[keccak288Test.GetDigestSize()];
* keccak288Test.BlockUpdate(source, 0, source.Length);
* keccak288Test.DoFinal(output4, 0);
* var target4 = System.Convert.FromBase64String("");*/
var output5 = new byte[keccak384Test.GetDigestSize()];
keccak384Test.BlockUpdate(source, 0, source.Length);
keccak384Test.DoFinal(output5, 0);
var target5 = Base16.Decode("B1EA01288A8ECA553687E92943FC8E8D22B3B918462B7708FCB011B8EF28F60E7072FE2623E624DEBD00F8CF46B1F967"); //https://asecuritysite.com/encryption/sha3
var output6 = new byte[keccak512Test.GetDigestSize()];
keccak512Test.BlockUpdate(source, 0, source.Length);
keccak512Test.DoFinal(output6, 0);
var target6 = Base16.Decode("1057C35F3364A9C7D7EFB5B2AB48D9A71373DCA1E3680CBF6734DA5E896DD7DE2901A678240A1C936598A6C58E6253A9747E2715BBD559AA9A5DA9302B815BAC"); //https://asecuritysite.com/encryption/sha3
//Assert.IsTrue(output1.SequenceEqual(target1));
//Assert.IsTrue(output2.SequenceEqual(target2));
Assert.IsTrue(output3.SequenceEqual(target3));
//Assert.IsTrue(output4.SequenceEqual(target4));
Assert.IsTrue(output5.SequenceEqual(target5));
Assert.IsTrue(output6.SequenceEqual(target6));
}
}
public static byte[] ToKeccakHash(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[] ComputeSha3KeccakDigest(byte[] data, int bitLength)
{
var digest = new KeccakDigest(bitLength);
byte[] buffer = new byte[digest.GetDigestSize()];
digest.BlockUpdate(data, 0, data.Length);
digest.DoFinal(buffer, 0);
return(buffer);
}
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);
}
/// <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));
}
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[] 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);
}
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);
}
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());
}
/// <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("-", ""));
}
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);
}
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 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 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);
}
