private MnemonicType GetMnomonicType(string normalizedMn)
{
using HmacSha512 hmac = new HmacSha512(Encoding.UTF8.GetBytes("Seed version"));
byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(normalizedMn));
if (hash[0] == 1)
{
return(MnemonicType.Standard);
}
else if (hash[0] == 0x10)
{
int second = hash[1] & 0xf0;
if (second == 0)
{
return(MnemonicType.SegWit);
}
else if (second == 0x10)
{
return(MnemonicType.Legacy2Fa);
}
else if (second == 0x20)
{
return(MnemonicType.SegWit2Fa);
}
}
return(MnemonicType.Undefined);
}
public void Constructor_ExceptionTest()
{
Assert.Throws <ArgumentNullException>(() => new HmacSha512(null));
HmacSha512 hmac = new HmacSha512();
Assert.Throws <ArgumentNullException>(() => hmac.Key = null);
}
public void ComputeHash_Empty_WithKey_Test(byte[] key, byte[] data)
{
using var sysHmac = new System.Security.Cryptography.HMACSHA512(key);
byte[] expected = sysHmac.ComputeHash(data);
using HmacSha512 hmac = new HmacSha512();
byte[] actual = hmac.ComputeHash(data, key);
Assert.Equal(expected, actual);
}
/// <summary>
/// Initializes a new instance of <see cref="BIP0085"/>.
/// </summary>
/// <exception cref="ArgumentException"/>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="ArgumentOutOfRangeException"/>
/// <exception cref="FormatException"/>
/// <param name="masterExtendedKey">Master extended key (xprv string)</param>
/// <param name="netType">
/// [Default value = <see cref="NetworkType.MainNet"/>]
/// The expected network that this extended key belongs to.
/// </param>
public BIP0085(string masterExtendedKey, NetworkType netType = NetworkType.MainNet)
{
bip32 = new BIP0032(masterExtendedKey, netType);
ReadOnlySpan <byte> empty = new byte[4];
if (!empty.SequenceEqual(bip32.ChildNumber) || !empty.SequenceEqual(bip32.ParentFingerPrint))
{
throw new ArgumentException("BIP-85 is only defined for master extended keys.", nameof(masterExtendedKey));
}
hmac = new HmacSha512();
}
public void ComputeHash_NIST_CtorKey_Test(byte[] msg, byte[] key, byte[] expected, int len, bool truncate)
{
using HmacSha512 hmac = new HmacSha512(key);
byte[] actual = hmac.ComputeHash(msg);
if (truncate)
{
byte[] temp = new byte[len];
Buffer.BlockCopy(actual, 0, temp, 0, len);
actual = temp;
}
Assert.Equal(expected, actual);
}
public static void Properties()
{
var a = new HmacSha512();
Assert.Equal(64, a.MinKeySize);
Assert.Equal(64, a.DefaultKeySize);
Assert.Equal(int.MaxValue, a.MaxKeySize);
Assert.Equal(16, a.MinMacSize);
Assert.Equal(64, a.DefaultMacSize);
Assert.Equal(64, a.MaxMacSize);
}
private unsafe void SetBip32(byte[] mnemonic)
{
HmacSha512 hmac = new HmacSha512(mnemonic);
byte[] salt = Encoding.UTF8.GetBytes($"mnemonic{passPhrase?.Normalize(NormalizationForm.FormKD)}");
byte[] saltForHmac = new byte[salt.Length + 4];
Buffer.BlockCopy(salt, 0, saltForHmac, 0, salt.Length);
byte[] seed = new byte[64];
fixed(byte *saltPt = &saltForHmac[salt.Length])
{
// F()
byte[] resultOfF = new byte[hmac.OutputSize];
// Concatinate i after salt
//saltPt[0] = (byte)(1 >> 24);
//saltPt[1] = (byte)(1 >> 16);
//saltPt[2] = (byte)(1 >> 8);
saltPt[3] = 1;
// compute u1
byte[] u1 = hmac.ComputeHash(saltForHmac);
Buffer.BlockCopy(u1, 0, resultOfF, 0, u1.Length);
// compute u2 to u(c-1) where c is iteration and each u is the hmac of previous u
for (int j = 1; j < 2048; j++)
{
u1 = hmac.ComputeHash(u1);
// result of F() is XOR sum of all u arrays
int len = u1.Length;
fixed(byte *first = resultOfF, second = u1)
{
byte *fp = first;
byte *sp = second;
*(ulong *)fp ^= *(ulong *)sp;
*(ulong *)(fp + 8) ^= *(ulong *)(sp + 8);
*(ulong *)(fp + 16) ^= *(ulong *)(sp + 16);
*(ulong *)(fp + 24) ^= *(ulong *)(sp + 24);
*(ulong *)(fp + 32) ^= *(ulong *)(sp + 32);
*(ulong *)(fp + 40) ^= *(ulong *)(sp + 40);
*(ulong *)(fp + 48) ^= *(ulong *)(sp + 48);
*(ulong *)(fp + 56) ^= *(ulong *)(sp + 56);
}
}
Buffer.BlockCopy(resultOfF, 0, seed, 0, resultOfF.Length);
}
}
public void ComputeHash_WithKey_ExceptionTest()
{
HmacSha512 hmac = new HmacSha512();
Exception ex = Assert.Throws <ArgumentNullException>(() => hmac.ComputeHash(null, new byte[1]));
Assert.Contains("Data can not be null", ex.Message);
ex = Assert.Throws <ArgumentNullException>(() => hmac.ComputeHash(new byte[1], null));
Assert.Contains("Key can not be null", ex.Message);
hmac.Dispose();
ex = Assert.Throws <ObjectDisposedException>(() => hmac.ComputeHash(new byte[1], new byte[1]));
}
public static void Test(string key, string msg, string mac)
{
var a = new HmacSha512();
using (var k = Key.Import(a, key.DecodeHex(), KeyBlobFormat.RawSymmetricKey))
{
var m = msg.DecodeHex();
var expected = mac.DecodeHex();
var actual = a.Sign(k, m, expected.Length);
Assert.Equal(expected, actual);
Assert.True(a.TryVerify(k, m, expected));
}
}
public void ComputeHash_Reuse_Test(byte[] key1, byte[] data1_1, byte[] exp1_1, byte[] data1_2, byte[] exp1_2,
byte[] key2, byte[] data2_1, byte[] exp2_1, byte[] data2_2, byte[] exp2_2)
{
using HmacSha512 hmac = new HmacSha512();
byte[] actual1_1 = hmac.ComputeHash(data1_1, key1);
Assert.Equal(exp1_1, actual1_1);
byte[] actual2_1 = hmac.ComputeHash(data2_1, key2); // use different key on each call
Assert.Equal(exp2_1, actual2_1);
byte[] actual1_2 = hmac.ComputeHash(data1_2, key1);
Assert.Equal(exp1_2, actual1_2);
byte[] actual2_2 = hmac.ComputeHash(data2_2, key2);
Assert.Equal(exp2_2, actual2_2);
}
public static void Properties()
{
var a = new HmacSha512();
Assert.Equal(64, HmacSha512.MinKeySize);
Assert.Equal(64, HmacSha512.MaxKeySize);
Assert.Equal(16, HmacSha512.MinMacSize);
Assert.Equal(64, HmacSha512.MaxMacSize);
Assert.Equal(64, a.KeySize);
Assert.Equal(64, a.MacSize);
Assert.Equal(64, MacAlgorithm.HmacSha512_256.KeySize);
Assert.Equal(32, MacAlgorithm.HmacSha512_256.MacSize);
Assert.Equal(64, MacAlgorithm.HmacSha512.KeySize);
Assert.Equal(64, MacAlgorithm.HmacSha512.MacSize);
}
public void ComputeHash_ExceptionTest()
{
HmacSha512 hmac = new HmacSha512();
Exception ex = Assert.Throws <ArgumentNullException>(() => hmac.ComputeHash(null));
Assert.Contains("Data can not be null", ex.Message);
ex = Assert.Throws <ArgumentNullException>(() => hmac.ComputeHash(new byte[1]));
Assert.Contains("Key must be set before calling this function", ex.Message);
hmac.Key = new byte[1];
ex = Assert.Throws <ArgumentNullException>(() => hmac.ComputeHash(null));
Assert.Contains("Data can not be null", ex.Message);
hmac.Dispose();
ex = Assert.Throws <ObjectDisposedException>(() => hmac.ComputeHash(new byte[1]));
}
public void ComputeHash_CtorKey_ReuseTest(byte[] key1, byte[] data1_1, byte[] exp1_1, byte[] data1_2, byte[] exp1_2,
byte[] key2, byte[] data2_1, byte[] exp2_1, byte[] data2_2, byte[] exp2_2)
{
using HmacSha512 hmac = new HmacSha512(key1);
byte[] actual1_1 = hmac.ComputeHash(data1_1);
Assert.Equal(exp1_1, actual1_1);
byte[] actual1_2 = hmac.ComputeHash(data1_2);
Assert.Equal(exp1_2, actual1_2);
// change key
hmac.Key = key2;
byte[] actual2_1 = hmac.ComputeHash(data2_1);
Assert.Equal(exp2_1, actual2_1);
byte[] actual2_2 = hmac.ComputeHash(data2_2);
Assert.Equal(exp2_2, actual2_2);
}
/// <summary>
/// Releases the resources used by the <see cref="BIP0032"/> class.
/// </summary>
/// <param name="disposing">
/// True to release both managed and unmanaged resources; false to release only unmanaged resources.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!isDisposed)
{
if (disposing)
{
if (!(hmac is null))
{
hmac.Dispose();
}
hmac = null;
if (!(PrvKey is null))
{
PrvKey.Dispose();
}
PrvKey = null;
PubKey = null;
if (ChainCode != null)
{
Array.Clear(ChainCode, 0, ChainCode.Length);
}
ChainCode = null;
if (ParentFingerPrint != null)
{
Array.Clear(ParentFingerPrint, 0, ParentFingerPrint.Length);
}
ParentFingerPrint = null;
if (ChildNumber != null)
{
Array.Clear(ChildNumber, 0, ChildNumber.Length);
}
ChildNumber = null;
b58Encoder = null;
}
isDisposed = true;
}
}
public void ConstructorTest(byte[] key, bool isKeyHashed)
{
using var sysHmac = new System.Security.Cryptography.HMACSHA512(key);
byte[] expectedKey = sysHmac.Key;
// Set key in constructor:
using (HmacSha512 hmac = new HmacSha512(key))
{
Assert.Equal(expectedKey, hmac.Key);
if (!isKeyHashed)
{
Assert.Equal(key, hmac.Key);
// Make sure small unhashed keys are cloned
Assert.NotSame(key, hmac.Key);
}
else
{
Assert.NotEqual(key, hmac.Key);
}
}
// Set key using the property:
using (HmacSha512 hmac = new HmacSha512())
{
Assert.Null(hmac.Key);
hmac.Key = key;
if (!isKeyHashed)
{
Assert.Equal(key, hmac.Key);
// Make sure small unhashed keys are cloned
Assert.NotSame(key, hmac.Key);
}
else
{
Assert.NotEqual(key, hmac.Key);
}
}
}
public static byte[] GenerateChecksum(string checksum, int offset, byte[] buffer, int eof = -1)
{
byte[] returnValue = null;
switch (checksum)
{
case "Adler8 - {1Bytes}":
returnValue = eof == -1 ? Adler8.Compute(offset, buffer) : Adler8.Compute(offset, buffer, eof);
break;
case "Adler16 - {2Bytes}":
returnValue = eof == -1 ? Adler16.Compute(offset, buffer) : Adler16.Compute(offset, buffer, eof);
break;
case "Adler32 - {4Bytes}":
returnValue = eof == -1 ? Adler32.Compute(offset, buffer) : Adler32.Compute(offset, buffer, eof);
break;
case "Checksum8 - {1Bytes}":
returnValue = eof == -1 ? Checksum8.Compute(offset, buffer) : Checksum8.Compute(offset, buffer, eof);
break;
case "Checksum16 - {2Bytes}":
returnValue = eof == -1 ? Checksum16.Compute(offset, buffer) : Checksum16.Compute(offset, buffer, eof);
break;
case "Checksum24 - {3Bytes}":
returnValue = eof == -1 ? Checksum24.Compute(offset, buffer) : Checksum24.Compute(offset, buffer, eof);
break;
case "Checksum32 - {4Bytes}":
returnValue = eof == -1 ? Checksum32.Compute(offset, buffer) : Checksum32.Compute(offset, buffer, eof);
break;
case "Checksum40 - {5Bytes}":
returnValue = eof == -1 ? Checksum40.Compute(offset, buffer) : Checksum40.Compute(offset, buffer, eof);
break;
case "Checksum48 - {6Bytes}":
returnValue = eof == -1 ? Checksum48.Compute(offset, buffer) : Checksum48.Compute(offset, buffer, eof);
break;
case "Checksum56 - {7Bytes}":
returnValue = eof == -1 ? Checksum56.Compute(offset, buffer) : Checksum56.Compute(offset, buffer, eof);
break;
case "Checksum64 - {8Bytes}":
returnValue = eof == -1 ? Checksum64.Compute(offset, buffer) : Checksum64.Compute(offset, buffer, eof);
break;
case "CRC16 - {2Bytes}":
Crc16 crc16 = new Crc16();
returnValue = eof == -1 ? crc16.Compute(offset, buffer) : crc16.Compute(offset, buffer, eof);
break;
case "CRC16 CCITT - {2Bytes}":
Crc16ccitt crc16Ccitt = new Crc16ccitt();
returnValue = eof == -1 ? crc16Ccitt.Compute(offset, buffer) : crc16Ccitt.Compute(offset, buffer, eof);
break;
case "CRC32 - {4Bytes}":
returnValue = eof == -1 ? Crc32.Compute(offset, buffer) : Crc32.Compute(offset, buffer, eof);
break;
case "HMAC SHA 1 (128) - {16Bytes}":
returnValue = eof == -1 ? HmacSha1.Compute(offset, buffer) : HmacSha1.Compute(offset, buffer, eof);
break;
case "HMAC SHA 256 - {32Bytes}":
returnValue = eof == -1 ? HmacSha256.Compute(offset, buffer) : HmacSha256.Compute(offset, buffer, eof);
break;
case "HMAC SHA 384 - {48Bytes}":
returnValue = eof == -1 ? HmacSha384.Compute(offset, buffer) : HmacSha384.Compute(offset, buffer, eof);
break;
case "HMAC SHA 512 - {64Bytes}":
returnValue = eof == -1 ? HmacSha512.Compute(offset, buffer) : HmacSha512.Compute(offset, buffer, eof);
break;
case "MD5 - {16Bytes}":
returnValue = eof == -1 ? Md5.Compute(offset, buffer) : Md5.Compute(offset, buffer, eof);
break;
case "MD5 CNG - {16Bytes}":
returnValue = eof == -1 ? Md5Cng.Compute(offset, buffer) : Md5Cng.Compute(offset, buffer, eof);
break;
}
return(returnValue);
}
public void ComputeHash_rfc_CtorKey_Test(byte[] msg, byte[] key, byte[] expected)
{
using HmacSha512 hmac = new HmacSha512(key);
byte[] actual = hmac.ComputeHash(msg);
Assert.Equal(expected, actual);
}