public void Decrypt()
{
try
{
if (m_vType == 10101)
{
byte[] cipherText = m_vData;
Client.CPublicKey = cipherText.Take(32).ToArray();
Hasher b = Blake2B.Create(new Blake2BConfig
{
OutputSizeInBytes = 24
});
b.Init();
b.Update(Client.CPublicKey);
b.Update(Key.Crypto.PublicKey);
Client.CRNonce = b.Finish();
cipherText = CustomNaCl.OpenPublicBox(cipherText.Skip(32).ToArray(), Client.CRNonce, Key.Crypto.PrivateKey, Client.CPublicKey);
Client.CSharedKey = Client.CPublicKey;
Client.CSessionKey = cipherText.Take(24).ToArray();
Client.CSNonce = cipherText.Skip(24).Take(24).ToArray();
Client.CState = 1;
SetData(cipherText.Skip(48).ToArray());
}
else if (m_vType != 10100)
{
Client.CSNonce.Increment();
SetData(CustomNaCl.OpenSecretBox(new byte[16].Concat(m_vData).ToArray(), Client.CSNonce, Client.CSharedKey));
}
}
catch (Exception ex)
{
Client.CState = 0;
}
}
public bool ValidateAddress(string address)
{
if (address.Length != 64 && !address.StartsWith("xrb_"))
{
return(false);
}
var pk32 = address.Substring(4, 52);
var pk = Base32withPadding.Decode(pk32, _base32Alphabet, 4);
var checksum = address.Substring(56);
var checksumDecoded = Base32withPadding.Decode(checksum, _base32Alphabet, 0);
checksumDecoded = checksumDecoded.Reverse().ToArray();
var blake2bConfig = new Blake2BConfig
{
OutputSizeInBytes = 5
};
var hasher = Blake2B.Create(blake2bConfig);
hasher.Update(pk);
var pkChecksum = hasher.Finish();
return(pkChecksum.SequenceEqual(checksumDecoded));
}
/// <summary>
/// Hashes the specified payload.
/// </summary>
/// <param name="payload">The payload.</param>
/// <param name="size">The size.</param>
/// <returns>System.Byte[].</returns>
public byte[] Hash(byte[] payload, int size)
{
var nKey = new byte[size];
//using (var random = new RNGCryptoServiceProvider())
// random.GetBytes(nKey);
RandomNumberGenerator.Create().GetBytes(nKey);
// Using Paseto Cryptography library
using (var hash = new Blake2B())
return(hash.ComputeHash(nKey));
/*
* Using NSec library
*
* var algo = new Blake2bMac();
* using (var key = Key.Import(algo, nKey, KeyBlobFormat.RawSymmetricKey))
* return algo.Mac(key, payload, size);
*/
// Using Sodium Core library
//var hash = new GenericHash.GenericHashAlgorithm(nKey, size);
//return hash.ComputeHash(GetBytes(payload));
}
public static string HashStateBlock(string accountAddress, string previousHash, string balance, string representativeAccount, string link)
{
var representativePublicKey = AddressToPublicKey(representativeAccount);
var accountPublicKey = AddressToPublicKey(accountAddress);
var previousBytes = HexStringToByteArray(previousHash);
var balanceHex = BigInteger.Parse(balance).ToString("X");
if (balanceHex.Length % 2 == 1)
{
balanceHex = "0" + balanceHex;
}
byte[] balanceBytes = HexStringToByteArray(balanceHex.PadLeft(32, '0'));
var linkBytes = HexStringToByteArray(link);
var preamble = HexStringToByteArray("0000000000000000000000000000000000000000000000000000000000000006");
var blake = Blake2B.Create(new Blake2BConfig()
{
OutputSizeInBytes = 32
});
blake.Init();
blake.Update(preamble);
blake.Update(accountPublicKey);
blake.Update(previousBytes);
blake.Update(representativePublicKey);
blake.Update(balanceBytes);
blake.Update(linkBytes);
var hashBytes = blake.Finish();
return(ByteArrayToHex(hashBytes));
}
private static Blake2B MakeBlake2BInstanceAndInitialize(int hashSize)
{
var hashInstance = new Blake2B(new Blake2BConfig(hashSize));
hashInstance.Initialize();
return(hashInstance);
}
public static void crypto_sign_keypair(byte[] pk, int pkoffset, byte[] sk, int skoffset, byte[] seed, int seedoffset)
{
GroupElementP3 A;
int i;
Array.Copy(seed, seedoffset, sk, skoffset, 32);
var blake2bConfig = new Blake2BConfig
{
OutputSizeInBytes = 64
};
var hasher = Blake2B.Create(blake2bConfig);
hasher.Update(sk, skoffset, 32);
byte[] h = hasher.Finish();
//byte[] h = Sha512.Hash(sk, skoffset, 32);//ToDo: Remove alloc
ScalarOperations.sc_clamp(h, 0);
GroupOperations.ge_scalarmult_base(out A, h, 0);
GroupOperations.ge_p3_tobytes(pk, pkoffset, ref A);
for (i = 0; i < 32; ++i)
{
sk[skoffset + 32 + i] = pk[pkoffset + i];
}
CryptoBytes.Wipe(h);
}
public void Decrypt()
{
try
{
if (Constants.IsRc4)
{
Client.Decrypt(m_vData);
if (m_vType == 10101)
{
Client.State = ClientState.Login;
}
// No need since the decryption occurs on same buffer.
//SetData(m_vData);
}
else
{
if (m_vType == 10101)
{
var cipherText = m_vData;
Client.CPublicKey = cipherText.Take(32).ToArray();
var blake = Blake2B.Create(new Blake2BConfig
{
OutputSizeInBytes = 24
});
blake.Init();
blake.Update(Client.CPublicKey);
blake.Update(Key.Crypto.PublicKey);
Client.CRNonce = blake.Finish();
cipherText = CustomNaCl.OpenPublicBox(cipherText.Skip(32).ToArray(), Client.CRNonce, Key.Crypto.PrivateKey, Client.CPublicKey);
Client.CSharedKey = Client.CPublicKey;
Client.CSessionKey = cipherText.Take(24).ToArray();
Client.CSNonce = cipherText.Skip(24).Take(24).ToArray();
Client.State = ClientState.Login;
SetData(cipherText.Skip(48).ToArray());
}
else
{
if (m_vType != 10100)
{
if (Client.State == ClientState.LoginSuccess)
{
Client.CSNonce.Increment();
SetData(CustomNaCl.OpenSecretBox(new byte[16].Concat(m_vData).ToArray(), Client.CSNonce, Client.CSharedKey));
}
}
}
}
}
catch
{
Client.State = ClientState.Exception;
throw;
}
}
public string EncodeAccount(UInt256 account)
{
var hasher = Blake2B.Create(new Blake2BConfig
{
OutputSizeInBytes = 5
});
var bytes = account.ToByteArray().Reverse().ToArray();
hasher.Update(bytes);
byte[] checkBytes = hasher.Finish();
Array.Resize(ref checkBytes, 8);
UInt64 check = BitConverter.ToUInt64(checkBytes, 0);
BigInteger number = Number(bytes);
number <<= 40;
number |= new BigInteger(check);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 60; i++)
{
var r = number.ToByteArray()[0] & 0x1f;
number >>= 5;
sb.Append(AccountLookup[r]);
}
sb.Append("_brx");
var addrReverse = sb.ToString();
var arr = addrReverse.ToCharArray();
Array.Reverse(arr);
return(new string(arr));
}
public void Encrypt(byte[] plainText)
{
try
{
if (GetMessageType() == 20104 || GetMessageType() == 20103)
{
Hasher b = Blake2B.Create(new Blake2BConfig
{
OutputSizeInBytes = 24
});
b.Init();
b.Update(Client.CSNonce);
b.Update(Client.CPublicKey);
b.Update(Key.Crypto.PublicKey);
SetData(CustomNaCl.CreatePublicBox(Client.CRNonce.Concat(Client.CSharedKey).Concat(plainText).ToArray(), b.Finish(), Key.Crypto.PrivateKey, Client.CPublicKey));
if (GetMessageType() == 20104)
{
Client.CState = 2;
}
}
else
{
Client.CRNonce.Increment();
SetData(CustomNaCl.CreateSecretBox(plainText, Client.CRNonce, Client.CSharedKey).Skip(16).ToArray());
}
}
catch (Exception)
{
Client.CState = 0;
}
}
/*
* bool Proof::Test()
* {
* uint32_t input[SEED_LENGTH + 2];
* for (unsigned i = 0; i < SEED_LENGTH; ++i)
* input[i] = seed[i];
* input[SEED_LENGTH] = nonce;
* input[SEED_LENGTH + 1] = 0;
* uint32_t buf[MAX_N / 4];
* std::vector<uint32_t> blocks(k + 1, 0);
* for (unsigned i = 0; i < inputs.size(); ++i)
* {
* input[SEED_LENGTH + 1] = inputs[i];
* blake2b((uint8_t*)buf, &input, NULL, sizeof(buf), sizeof(input), 0);
* for (unsigned j = 0; j < (k + 1); ++j)
* {
* //select j-th block of n/(k+1) bits
* blocks[j] ^= buf[j] >> (32 - n / (k + 1));
* }
* }
* bool b = true;
* for (unsigned j = 0; j < (k + 1); ++j)
* {
* b &= (blocks[j] == 0);
* }
* if (b && inputs.size() != 0)
* {
* printf("Solution found:\n");
* for (unsigned i = 0; i < inputs.size(); ++i)
* {
* printf(" %x ", inputs[i]);
* }
* printf("\n");
* }
* return b;
* }
*/
public bool Test()
{
uint[] input = new uint[Equihash.SEED_LENGTH + 2];
for (uint i = 0; i < Equihash.SEED_LENGTH; ++i)
{
input[i] = seed[i];
}
input[Equihash.SEED_LENGTH] = nonce;
input[Equihash.SEED_LENGTH + 1] = 0;
uint[] buf = new uint[Equihash.MAX_N / 4];
List <uint> blocks = new List <uint>(); for (int i = 0; i < k + 1; i++)
{
blocks.Add(0);
}
for (int i = 0; i < inputs.Count; ++i)
{
input[Equihash.SEED_LENGTH + 1] = inputs[i];
byte[] inputBytes;
using (MemoryStream ms = new MemoryStream())
{
for (int x = 0; x < input.Length; x++)
{
ms.Write(BitConverter.GetBytes(input[x]), 0, 4);
}
inputBytes = ms.ToArray();
}
Blake2B blake2b = new Blake2B(256);
byte[] result = blake2b.ComputeHash(inputBytes);
for (int x = 0; x < buf.Length; x++)
{
buf[x] = BitConverter.ToUInt32(result, x * 4);
}
for (int j = 0; j < (k + 1); ++j)
{
//select j-th block of n/(k+1) bits
blocks[j] = blocks[j] ^ (buf[j] >> (int)(32 - n / (k + 1)));
}
}
bool b = true;
for (int j = 0; j < (k + 1); ++j)
{
b = (blocks[j] == 0);
}
if (b && inputs.Count != 0)
{
Console.WriteLine("Solution found:");
for (int i = 0; i < inputs.Count; ++i)
{
Console.Write($" {inputs[i]} ");
}
Console.WriteLine("");
}
return(b);
}
/// <summary>Blake2 hashed with bytes concated at the end.</summary>
/// <param name="bytes">The bytes.</param>
/// <param name="size">The size.</param>
/// <returns>
/// <br />
/// </returns>
public static byte[] Blake2Concat(byte[] bytes, int size = 128)
{
var config = new Blake2BConfig {
OutputSizeInBits = size, Key = null
};
return(Blake2B.ComputeHash(bytes, config).Concat(bytes).ToArray());
}
/// <summary>Blake2 hashed the specified bytes.</summary>
/// <param name="bytes">The bytes.</param>
/// <param name="size">The size.</param>
/// <param name="key">The key.</param>
/// <returns>
/// <br />
/// </returns>
public static byte[] Blake2(byte[] bytes, int size = 128, IReadOnlyList <byte> key = null)
{
var config = new Blake2BConfig {
OutputSizeInBits = size, Key = null
};
return(Blake2B.ComputeHash(bytes, config));
}
public byte[] Blake2b(byte[] input)
{
var blakeConfig = new Blake2BConfig {
OutputSizeInBits = 256
};
return(Blake2B.ComputeHash(input, 0, input.Count(), blakeConfig));
}
public static byte[] FastHash(byte[] message, int offset, int length)
{
var blakeConfig = new Blake2BConfig {
OutputSizeInBits = 256
};
return(Blake2B.ComputeHash(message, offset, length, blakeConfig));
}
public string CalculateMessageNetworkId()
{
var networkIdBytes = Blake2B.ComputeHash(Encoding.ASCII.GetBytes(this.NetworkId), new Blake2BConfig {
OutputSizeInBytes = 32
}, null);
return(BitConverter.ToInt64(networkIdBytes.Take(8).ToArray(), 0).ToString());
}
public static byte[] SecureHash(byte[] message, int offset, int lenght)
{
var blakeConfig = new Blake2BConfig {
OutputSizeInBits = 256
};
var blake2B = Blake2B.ComputeHash(message, offset, lenght, blakeConfig);
return(Hash(blake2B, 0, blake2B.Length, Keccak256));
}
private static byte[] CalculateBlake2StrongSum(byte[] block)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
Blake2BConfig val = new Blake2BConfig();
val.set_OutputSizeInBytes(32);
return(Blake2B.ComputeHash(block, val));
}
// Generate blake2b nonce with clientkey(pk) and serverkey.
private static byte[] GenerateBlake2BNonce(byte[] clientKey, byte[] serverKey)
{
var hashBuffer = new byte[clientKey.Length + serverKey.Length];
Buffer.BlockCopy(clientKey, 0, hashBuffer, 0, clientKey.Length);
Buffer.BlockCopy(serverKey, 0, hashBuffer, PublicKeyBox.PublicKeyLength, serverKey.Length);
using (var blake = new Blake2B(24))
return(blake.ComputeHash(hashBuffer));
}
protected BLAKE2B(int bits)
: base(GetHashType(bits), GetName(bits), bits / 8)
{
_factory = () =>
{
var algo = new Blake2B(bits);
algo.Initialize();
return(algo);
};
}
static readonly byte[] personalization = new byte[] { 99, 107, 98, 45, 100, 101, 102, 97, 117, 108, 116, 45, 104, 97, 115, 104 }; // ckb-default-hash
public static byte[] ComputeHash(byte[] data)
{
Blake2BConfig config = new Blake2BConfig
{
Personalization = personalization,
OutputSizeInBytes = 32
};
SecureArrayCall secureArrayCall = default;
return(Blake2B.ComputeHash(data, config, secureArrayCall));
}
/// <inheritdoc />
public long DoPow(byte[] message, int targetScore)
{
var relevantMessagePart = message.Take(message.Length - 8).ToArray();
var digest = Blake2B.ComputeHash(relevantMessagePart, new Blake2BConfig {
OutputSizeInBytes = 32
}, null);
var targetZeros = (int)Math.Ceiling(Math.Log((relevantMessagePart.Length + 8) * targetScore) / this.LN3);
return(this.DoWork(digest, targetZeros));
}
public void Hash(Blake2BConfig config, byte[] message)
{
var hasher = Blake2B.Create(new Blake2BConfig()
{
OutputSizeInBytes = 64
});
hasher.Init();
hasher.Update(Previous.ToByteArray());
hasher.Update(Source.ToByteArray());
}
/// <summary>
/// get the Blake2b-512 encrypt
/// </summary>
/// <param name="byteArrayToEncrypt">Byte array to encrypt</param>
/// <returns></returns>
public static string Blake2b_512Hash(this byte[] byteArrayToEncrypt)
{
StringBuilder sBuilder = new StringBuilder();
foreach (var encryptedByte in Blake2B.ComputeHash(byteArrayToEncrypt))
{
sBuilder.Append(encryptedByte.ToString("x2"));
}
return(sBuilder.ToString());
}
public static byte[] Hash(byte[] data, int size)
{
var hasher = Blake2B.Create(new Blake2BConfig
{
OutputSizeInBytes = size,
});
hasher.Init();
hasher.Update(data);
return(hasher.Finish());
}
public void CheckTestVectors()
{
for (int len = 0; len < TestVectors.UnkeyedBlake2B.Length; len++)
{
var input = Enumerable.Range(0, len).Select(i => (byte)i).ToArray();
var hash = Blake2B.ComputeHash(input);
string actual = BitConverter.ToString(hash).Replace("-", "");
string expected = TestVectors.UnkeyedBlake2B[len];
Assert.AreEqual(expected, actual);
}
}
public void Hash(Blake2BConfig config, byte[] message)
{
var hasher = Blake2B.Create(new Blake2BConfig()
{
OutputSizeInBytes = 64
});
hasher.Init();
hasher.Update(Source.ToByteArray());
hasher.Update(Representative.ToByteArray());
hasher.Update(Account.ToByteArray());
}
public static Ed25519Address FromPublicKey(byte[] publicKey)
{
var addressHash = Blake2B.ComputeHash(publicKey, new Blake2BConfig {
OutputSizeInBytes = 32
}, null);
return(new Ed25519Address
{
Address = addressHash.ToHex(),
PublicKey = publicKey
});
}
private static void AddByteString(Blake2B hashInstance, byte[] octets)
{
if (octets.Length > 0)
{
AddIntToLittleEndian(hashInstance, octets.Length);
hashInstance.TransformBytes(octets, 0, octets.Length);
}
else
{
AddIntToLittleEndian(hashInstance, 0);
}
}
public static string HashB64EncodedSalt(string password, string salt)
{
if (String.IsNullOrEmpty(password) || String.IsNullOrEmpty(salt))
{
throw new InvalidOperationException();
}
Blake2B blake2B = new Blake2B();
blake2B.Salt = EncodingUtils.Base64Decode(salt);
blake2B.Key = StringUtils.GetBytes(password);
byte[] data = blake2B.Final();
return(EncodingUtils.Base64Encode(data));
}
// 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[] h;
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 blake2bConfig = new Blake2BConfig
{
OutputSizeInBytes = 64
};
var hasher = Blake2B.Create(blake2bConfig);
hasher.Update(sig, sigoffset, 32);
hasher.Update(pk, pkoffset, 32);
hasher.Update(m, moffset, mlen);
h = hasher.Finish();
/*
* var hasher = new Sha512();
* hasher.Update(sig, sigoffset, 32);
* hasher.Update(pk, pkoffset, 32);
* hasher.Update(m, moffset, mlen);
* h = hasher.Finish();
*/
ScalarOperations.sc_reduce(h);
var sm32 = new byte[32];//todo: remove allocation
Array.Copy(sig, sigoffset + 32, sm32, 0, 32);
GroupOperations.ge_double_scalarmult_vartime(out R, h, ref A, sm32);
GroupOperations.ge_tobytes(checkr, 0, ref R);
var result = CryptoBytes.ConstantTimeEquals(checkr, 0, sig, sigoffset, 32);
CryptoBytes.Wipe(h);
CryptoBytes.Wipe(checkr);
return(result);
}
