private void Serialize()
{
// transaction type. Set as null/empty bytes as it will be
// updated when serializing the different transaction types.
Serializer.WriteInt(TransactionType.MultisigTransaction);
// version
Serializer.WriteInt(TransactionVersion.VersionOne);
// timestamp
Serializer.WriteInt(TimeStamp);
//pubKey len
Serializer.WriteInt(ByteLength.PublicKeyLength);
// pub key
Serializer.WriteBytes(CryptoBytes.FromHexString(PublicKey.Raw));
// fee
Serializer.WriteLong(Fee);
// deadline
Serializer.WriteInt(Deadline);
Serializer.WriteInt(InnerLength);
}
public void HChaCha20StateTestVector()
{
// https://tools.ietf.org/html/draft-irtf-cfrg-xchacha-03#section-2.2.1
// Arrange
var key = CryptoBytes.FromHexString("00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f".Replace(":", string.Empty));
var nonce = CryptoBytes.FromHexString("00:00:00:09:00:00:00:4a:00:00:00:00:31:41:59:27".Replace(":", string.Empty));
var cipher = new XChaCha20(key, 0);
// Act
var initialState = new uint[16];
cipher.HChaCha20InitialState(initialState, nonce);
// Assert
var expectedInitialState = new uint[]
{
0x61707865, 0x3320646e, 0x79622d32, 0x6b206574,
0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c,
0x13121110, 0x17161514, 0x1b1a1918, 0x1f1e1d1c,
0x09000000, 0x4a000000, 0x00000000, 0x27594131
};
initialState.Should().BeEquivalentTo(expectedInitialState);
}
public void HChaCha20BlockTestVector()
{
// https://tools.ietf.org/html/draft-irtf-cfrg-xchacha-03#section-2.2.1
// Arrange
var key = CryptoBytes.FromHexString("00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f".Replace(":", string.Empty));
var nonce = CryptoBytes.FromHexString("00:00:00:09:00:00:00:4a:00:00:00:00:31:41:59:27".Replace(":", string.Empty));
var cipher = new XChaCha20(key, 0);
// Act
var subKey = new byte[32];
cipher.HChaCha20(subKey, nonce);
var state = subKey.ToUInt16Array();
//var stateHex = CryptoBytes.ToHexStringLower(subKey.ToArray());
// Assert
// HChaCha20 returns only the first and last rows
var expectedState = new uint[]
{
0x423b4182, 0xfe7bb227, 0x50420ed3, 0x737d878a,
//0x0aa76448, 0x7954cdf3, 0x846acd37, 0x7b3c58ad,
//0x77e35583, 0x83e77c12, 0xe0076a2d, 0xbc6cd0e5,
0xd5e4f9a0, 0x53a8748a, 0x13c42ec1, 0xdcecd326
};
// Same as above but in HEX
//var expectedStateHex = "82413b4" + "227b27bfe" + "d30e4250" + "8a877d73"
// + "a0f9e4d" + "58a74a853" + "c12ec413" + "26d3ecdc";
state.Should().BeEquivalentTo(expectedState);
//stateHex.Should().Be(expectedStateHex);
}
public void ChaCha20BlockTestVector()
{
// https://tools.ietf.org/html/rfc8439#section-2.3.2
// Arrange
var key = CryptoBytes.FromHexString("00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f".Replace(":", string.Empty));
var nonce = CryptoBytes.FromHexString("00:00:00:09:00:00:00:4a:00:00:00:00".Replace(":", string.Empty));
var counter = 1;
// Act
var chacha20 = new ChaCha20(key, 1);
var output = new byte[ChaCha20.BLOCK_SIZE_IN_BYTES];
chacha20.ProcessKeyStreamBlock(nonce, counter, output);
// Assert
var expected = new uint[16]
{
0xe4e7f110, 0x15593bd1, 0x1fdd0f50, 0xc47120a3,
0xc7f4d1c7, 0x0368c033, 0x9aaa2204, 0x4e6cd4c3,
0x466482d2, 0x09aa9f07, 0x05d7c214, 0xa2028bd9,
0xd19c12b5, 0xb94e16de, 0xe883d0cb, 0x4e3c50a2,
};
output.ToUInt16Array().Should().Equal(expected);
}
public static string PublicKeyToAddress(byte[] publicKey, int networkPrefix)
{
KeccakDigest shaDigest = new KeccakDigest(256);
byte[] bytesFirst = new byte[32];
shaDigest.BlockUpdate(publicKey, 0, 32);
shaDigest.DoFinal(bytesFirst, 0);
RipeMD160Digest digestRipeMd160 = new RipeMD160Digest();
byte[] bytesSecond = new byte[20];
digestRipeMd160.BlockUpdate(bytesFirst, 0, 32);
digestRipeMd160.DoFinal(bytesSecond, 0);
byte[] bytesThird = CryptoBytes.FromHexString(
string.Concat(networkPrefix,
CryptoBytes.ToHexStringLower(bytesSecond))
);
byte[] bytesFourth = new byte[32];
shaDigest.BlockUpdate(bytesThird, 0, 21);
shaDigest.DoFinal(bytesFourth, 0);
byte[] bytesFifth = new byte[4];
Array.Copy(bytesFourth, 0, bytesFifth, 0, 4);
byte[] bytesSixth = new byte[25];
Array.Copy(bytesThird, 0, bytesSixth, 0, 21);
Array.Copy(bytesFifth, 0, bytesSixth, 21, 4);
return(Base32.Encode(bytesSixth).ToUpper());
}
public void Poly1305TestVector4()
{
// Tests against the test vector 4 in Appendix A.3 of RFC 7539.
// https://tools.ietf.org/html/rfc7539#appendix-A.3
// Arrange
var key = CryptoBytes.FromHexString("1c9240a5eb55d38af333888604f6b5f0"
+ "473917c1402b80099dca5cbc207075c0");
var dat = CryptoBytes.FromHexString("2754776173206272696c6c69672c2061"
+ "6e642074686520736c6974687920746f"
+ "7665730a446964206779726520616e64"
+ "2067696d626c6520696e207468652077"
+ "6162653a0a416c6c206d696d73792077"
+ "6572652074686520626f726f676f7665"
+ "732c0a416e6420746865206d6f6d6520"
+ "7261746873206f757467726162652e");
// Act
var mac = new byte[Poly1305.MAC_TAG_SIZE_IN_BYTES];
Poly1305.ComputeMac(key, dat, mac);
// Assert
mac.Should().Equal(CryptoBytes.FromHexString("4541669a7eaaee61e708dc7cbcc5eb62"));
}
private void Serialize()
{
TotalBytesLength += 4;
Serializer.WriteInt(Data.Modifications.Count);
foreach (var mod in Data.Modifications)
{
TotalBytesLength += StructureLength.AggregateModification + ByteLength.FourBytes;
Serializer.WriteInt(StructureLength.AggregateModification);
Serializer.WriteInt(mod.ModificationType);
Serializer.WriteInt(ByteLength.PublicKeyLength);
Serializer.WriteBytes(CryptoBytes.FromHexString(mod.PublicKey.Raw));
}
if (Data.RelativeChange != 0)
{
TotalBytesLength += StructureLength.RelativeChange + ByteLength.FourBytes;
Serializer.WriteInt(StructureLength.RelativeChange);
Serializer.WriteInt(Data.RelativeChange);
}
else
{
TotalBytesLength += ByteLength.FourBytes;
Serializer.WriteInt(ByteLength.Zero);
}
}
public static string Decode(string text, PrivateKey sk, string pk)
{
return(_Decode(
CryptoBytes.FromHexString(StringUtils.ConvertToUnsecureString(sk.Raw)),
CryptoBytes.FromHexString(pk),
CryptoBytes.FromHexString(text)));
}
private void Serialize()
{
var sumLen = 0;
foreach (var p in MosaicProperties)
{
sumLen += p.PropertyLength + 4;
}
Length = 60 + NamespaceId.Length
+ MosaicName.Length
+ Description.Length
+ sumLen;
// mosaic definition length
if (Model.MosaicLevy != null)
{
Serializer.WriteInt(Length + (Model.MosaicLevy.Length - 4));
}
else
{
Serializer.WriteInt(Length);
}
// length if creator public key
Serializer.WriteInt(ByteLength.PublicKeyLength);
// creator public key
Serializer.WriteBytes(CryptoBytes.FromHexString(Creator.Raw));
// mosaic id structure length
Serializer.WriteInt(ByteLength.EightBytes + NamespaceId.Length + MosaicName.Length);
// namespace id length
Serializer.WriteInt(NamespaceId.Length);
// namespace
Serializer.WriteBytes(NamespaceId);
// mosaic name length
Serializer.WriteInt(MosaicName.Length);
// mosaic name
Serializer.WriteBytes(MosaicName);
// description length
Serializer.WriteInt(Description.Length);
// description
Serializer.WriteBytes(Description);
// properties count
Serializer.WriteInt(MosaicProperties.Count);
foreach (var mp in MosaicProperties)
{
Serializer.WriteBytes(mp.GetBytes());
}
}
/// <summary>
/// Converts a hex string to an array of bytes.
/// </summary>
/// <param name="hexStr">Hex string to convert, it may optionally start with the "0x" prefix.</param>
/// <returns>Array of bytes.</returns>
public static byte[] HexStringToBytes(string hexStr)
{
if (hexStr.StartsWith("0x"))
{
return(CryptoBytes.FromHexString(hexStr.Substring(2)));
}
return(CryptoBytes.FromHexString(hexStr));
}
private void Serialize(PublicKey PublicKey)
{
Serializer.WriteBytes(TransferMode);
Serializer.WriteInt(ByteLength.PublicKeyLength);
Serializer.WriteBytes(CryptoBytes.FromHexString(PublicKey.Raw));
}
} // used to identify the benchmark test
public Rfc8439TestVector(string key, string plaintext, string nonce, string ciphertext, int initialCounter, string id)
{
Key = CryptoBytes.FromHexString(key);
PlainText = CryptoBytes.FromHexString(plaintext);
Nonce = CryptoBytes.FromHexString(nonce);
CipherText = CryptoBytes.FromHexString(ciphertext);
InitialCounter = initialCounter;
Id = id;
}
} // used to identify the benchmark test
public XChaCha20Poly1305TestVector(string key, string nonce, string plaintext, string aad, string ciphertext, string tag, string id)
{
Key = CryptoBytes.FromHexString(key);
Nonce = CryptoBytes.FromHexString(nonce);
PlainText = CryptoBytes.FromHexString(plaintext);
Aad = CryptoBytes.FromHexString(aad);
CipherText = CryptoBytes.FromHexString(ciphertext);
Tag = CryptoBytes.FromHexString(tag);
Id = id;
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyPair" /> class.
/// </summary>
/// <param name="privateKey">The private key</param>
/// <param name="publicKey">The public key</param>
public KeyPair(string privateKey, string publicKey)
{
Guard.NotNullOrEmpty(publicKey, nameof(publicKey));
Guard.NotEqualTo(publicKey.Length, 64, new ArgumentOutOfRangeException(nameof(publicKey)));
PrivateKeyString = privateKey;
PublicKeyString = publicKey;
//PrivateKey = privateKey.FromHex();
//PublicKey = publicKey.FromHex();
PrivateKey = CryptoBytes.FromHexString(privateKey);
PublicKey = CryptoBytes.FromHexString(publicKey);
}
public Salsa20TestVector(string name, string key, string iv, string block1, string block4, string block5, string block8)
{
Name = name;
Key = CryptoBytes.FromHexString(key);
IV = CryptoBytes.FromHexString(iv);
ExpectedBlock1 = block1;
ExpectedBlock4 = block4;
ExpectedBlock5 = block5;
ExpectedBlock8 = block8;
}
/// <summary>
/// Create KeyPair from private key
/// </summary>
/// <param name="privateKey">The private key</param>
/// <returns></returns>
public static KeyPair CreateFromPrivateKey(string privateKey)
{
Guard.NotNullOrEmpty(privateKey, nameof(privateKey));
Guard.NotEqualTo(privateKey.Length, 64, new ArgumentOutOfRangeException(nameof(privateKey)));
// var privateKeyArray = privateKey.FromHex();
// var publicKey = Ed25519.PublicKeyFromSeed(privateKeyArray).ToHexUpper();
var privateKeyArray = CryptoBytes.FromHexString(privateKey);
var publicKey = CryptoBytes.ToHexStringUpper(Ed25519.PublicKeyFromSeed(privateKeyArray));
return(new KeyPair(privateKey, publicKey));
}
private void Serialize()
{
Serializer.WriteInt(0x24);
Serializer.WriteInt(0x20);
Serializer.WriteBytes(CryptoBytes.FromHexString(Data.TransactionHash));
Serializer.WriteInt(0x28);
Serializer.WriteBytes(Encoding.UTF8.GetBytes(Data.MultisigAddress.Encoded));
}
/*
* Still no idea... doesnt work either.. cant seem to fix it..
* For some reason the produced hash isnt used and
* breaks even more when it is.. 0.o
*
*/
private static byte[] GetSharedKey(PrivateKey privateKey, string publicKey, byte[] salt)
{
var shared = new byte[32];
var hash = Ed25519.key_derive( // TODO: find out why hash isnt used.
shared,
salt,
CryptoBytes.FromHexString(publicKey),
CryptoBytes.FromHexString(StringUtils.ConvertToUnsecureString(privateKey.Raw)));
return(shared);
}
/// <summary>
/// Produces a public key from a given private key.
/// </summary>
/// <param name="privateKey">The private key to derive a public key from.</param>
/// <remarks>
/// As well as 64 char private keys, 66 char negative private keys are supported also supported. This does not affect the public key produced.
/// </remarks>
/// <returns>The derived public key string</returns>
/// <exception cref="ArgumentException">invalid private key. Exacption bounds: Must be only hex string. Must be equal to 64 or 66 chars in length.</exception>
/// <example>
/// This sample shows how to use the <see cref="ToPublicKey"/> method.
/// <code>
/// class TestClass
/// {
/// static void Main()
/// {
/// string publicKey = PublicKeyConversion.ToPublicKey(new PrivateKey("0705c2634de7e58325dabc58c4a794559be4d55d102d3aafcb189acb2e596add"));
/// }
/// }
/// </code>
/// </example>
public static string ToPublicKey(PrivateKey privateKey)
{
if (!StringUtils.OnlyHexInString(privateKey.Raw) ||
privateKey.Raw.Length == 64 && privateKey.Raw.Length == 66)
{
throw new ArgumentException("invalid private key");
}
var privateKeyArray = CryptoBytes.FromHexString(StringUtils.ConvertToUnsecureString(privateKey.Raw));
Array.Reverse(privateKeyArray);
return(CryptoBytes.ToHexStringLower(Ed25519.PublicKeyFromSeed(privateKeyArray)));
}
} // used to identify the benchmark test
public XChaCha20TestVector(string key, string nonce, string ciphertext, string plaintext, string id)
{
Key = CryptoBytes.FromHexString(key);
Nonce = CryptoBytes.FromHexString(nonce);
CipherText = CryptoBytes.FromHexString(ciphertext);
PlainText = CryptoBytes.FromHexString(plaintext);
if (plaintext.Length == 0)
{
PlainText = new byte[CipherText.Length];
}
Id = id;
}
public void Poly1305TestVector9()
{
// Tests against the test vector 9 in Appendix A.3 of RFC 7539.
// https://tools.ietf.org/html/rfc7539#appendix-A.3
// Arrange
var key = CryptoBytes.FromHexString("02000000000000000000000000000000"
+ "00000000000000000000000000000000");
var dat = CryptoBytes.FromHexString("fdffffffffffffffffffffffffffffff");
// Act
var mac = Poly1305.ComputeMac(key, dat);
// Assert
Assert.AreEqual(CryptoBytes.FromHexString("faffffffffffffffffffffffffffffff"), mac);
}
public void ComputeMacTest()
{
// Tests against the test vectors in Section 2.5.2 of RFC 7539.
// https://tools.ietf.org/html/rfc7539#section-2.5.2
// Arrange
var key = CryptoBytes.FromHexString("85d6be7857556d337f4452fe42d506a8"
+ "0103808afb0db2fd4abff6af4149f51b");
var dat = Encoding.UTF8.GetBytes("Cryptographic Forum Research Group");
// Act
var mac = Poly1305.ComputeMac(key, dat);
// Assert
Assert.AreEqual(CryptoBytes.FromHexString("a8061dc1305136c6c22b8baf0c0127a9"), mac);
}
public void Poly1305TestVector3()
{
// Tests against the test vector 3 in Appendix A.3 of RFC 7539.
// https://tools.ietf.org/html/rfc7539#appendix-A.3
// Arrange
var key = CryptoBytes.FromHexString("36e5f6b5c5e06070f0efca96227a863e"
+ "00000000000000000000000000000000");
var dat = Encoding.UTF8.GetBytes("Any submission to the IETF intended by the Contributor for publication as all or part of an IETF Internet-Draft or RFC and any statement made within the context of an IETF activity is considered an \"IETF Contribution\". Such statements include oral statements in IETF sessions, as well as written and electronic communications made at any time or place, which are addressed to");
// Act
var mac = Poly1305.ComputeMac(key, dat);
// Assert
Assert.AreEqual(CryptoBytes.FromHexString("f3477e7cd95417af89a6b8794c310cf0"), mac);
}
/// <summary>
/// Converts a public key to a main net or test net address. Network byte determines which network version to convert to.
/// </summary>
/// <param name="network">The network byte.</param>
/// <param name="publicKey">The public key.</param>
/// <returns>The unhyphenated address string.</returns>
/// <exception cref="ArgumentException">invalid public key. Thrown when a public key is not a 64 char hex string.</exception>
/// <example>
/// This sample shows how to use the <see cref="ToEncoded"/> method.
/// <code>
/// class TestClass
/// {
/// static void Main()
/// {
/// Connection connection = new Connection();
///
/// string address = AddressEncoding.ToEncoded(connection.GetNetworkVersion(), new PublicKey("0705c2634de7e58325dabc58c4a794559be4d55d102d3aafcb189acb2e596add"));
/// }
/// }
/// </code>
/// </example>
public static string ToEncoded(byte network, PublicKey publicKey)
{
if (!StringUtils.OnlyHexInString(publicKey.Raw) || publicKey.Raw.Length != 64)
{
throw new ArgumentException("invalid public key");
}
// step 1) sha-3(256) public key
var digestSha3 = new KeccakDigest(256);
var stepOne = new byte[32];
digestSha3.BlockUpdate(CryptoBytes.FromHexString(publicKey.Raw), 0, 32);
digestSha3.DoFinal(stepOne, 0);
// step 2) perform ripemd160 on previous step
var digestRipeMd160 = new RipeMD160Digest();
var stepTwo = new byte[20];
digestRipeMd160.BlockUpdate(stepOne, 0, 32);
digestRipeMd160.DoFinal(stepTwo, 0);
// step3) prepend network byte
var stepThree =
CryptoBytes.FromHexString(string.Concat(network == 0x68 ? 68 : 98, CryptoBytes.ToHexStringLower(stepTwo)));
// step 4) perform sha3 on previous step
var stepFour = new byte[32];
digestSha3.BlockUpdate(stepThree, 0, 21);
digestSha3.DoFinal(stepFour, 0);
// step 5) retrieve checksum
var stepFive = new byte[4];
Array.Copy(stepFour, 0, stepFive, 0, 4);
// step 6) append stepFive to resulst of stepThree
var stepSix = new byte[25];
Array.Copy(stepThree, 0, stepSix, 0, 21);
Array.Copy(stepFive, 0, stepSix, 21, 4);
// step 7) return base 32 encode address byte array
return(new Utils.Base32Encoder().Encode(stepSix).ToUpper());
}
public void Poly1305TestVector9()
{
// Tests against the test vector 9 in Appendix A.3 of RFC 7539.
// https://tools.ietf.org/html/rfc7539#appendix-A.3
// Arrange
var key = CryptoBytes.FromHexString("02000000000000000000000000000000"
+ "00000000000000000000000000000000");
var dat = CryptoBytes.FromHexString("fdffffffffffffffffffffffffffffff");
// Act
var mac = new byte[Poly1305.MAC_TAG_SIZE_IN_BYTES];
Poly1305.ComputeMac(key, dat, mac);
// Assert
mac.Should().Equal(CryptoBytes.FromHexString("faffffffffffffffffffffffffffffff"));
}
public void Poly1305TestVector11()
{
// Tests against the test vector 11 in Appendix A.3 of RFC 7539.
// https://tools.ietf.org/html/rfc7539#appendix-A.3
// Arrange
var key = CryptoBytes.FromHexString("01000000000000000400000000000000"
+ "00000000000000000000000000000000");
var dat = CryptoBytes.FromHexString("e33594d7505e43b90000000000000000"
+ "3394d7505e4379cd0100000000000000"
+ "00000000000000000000000000000000");
// Act
var mac = Poly1305.ComputeMac(key, dat);
// Assert
Assert.AreEqual(CryptoBytes.FromHexString("13000000000000000000000000000000"), mac);
}
public static string Encode(string text, PrivateKey sk, string pk)
{
SecureRandom random = new SecureRandom();
var salt = new byte[32];
random.NextBytes(salt);
var ivData = new byte[16];
random.NextBytes(ivData);
return(_Encode(
CryptoBytes.FromHexString(StringUtils.ConvertToUnsecureString(sk.Raw)),
CryptoBytes.FromHexString(pk),
text,
ivData,
salt));
}
/// <summary>
/// Initializes a new instance of the <see cref="Signature"/> class.
/// </summary>
/// <remarks>
/// Uses twisted edwards elliptic curve, Ed25519, to produce signatures.
/// </remarks>
/// <param name="data">The data bytes to sign.</param>
/// <param name="privateKey">The private key used to sign the bytes.</param>
/// <example>
/// This sample shows how to create a new instance of the <see cref="Signature"/> class and produce a signature.
/// <code>
/// class TestClass
/// {
/// static void Main()
/// {
/// byte[] bytes = new byte[10];
///
/// Signature sig = new Signature(bytes, new PrivateKey("0705c2634de7e58325dabc58c4a794559be4d55d102d3aafcb189acb2e596add"));
///
/// string signature = sig._Signature;
/// }
/// }
/// </code>
/// </example>
public Signature(byte[] data, PrivateKey privateKey)
{
var sig = new byte[64];
try
{
var sk = new byte[64];
Array.Copy(CryptoBytes.FromHexString(StringUtils.ConvertToUnsecureString(privateKey.Raw)), sk, 32);
Array.Copy(
CryptoBytes.FromHexString(
new PublicKey(PublicKeyConversion.ToPublicKey(privateKey)).Raw), 0,
sk, 32, 32);
Ed25519.crypto_sign2(sig, data, sk, 32);
CryptoBytes.Wipe(sk);
}
finally
{
_Signature = sig;
}
}
/*
* Constructs the message object and initiates its serialization
*
* @Param: Serializer, The serializer to use during serialization
* @Param: Message, The message string. Note: if null, a zero value byte[4] is serialized instead
* @Param: Encrypted, Whether the message should be encrypted or not
*/
internal Message(Connectivity.Connection con, PrivateKey senderKey, string address, string message, bool encrypted)
{
Encrypted = encrypted;
MessageString = message;
if (MessageString != null)
{
if (Encrypted)
{
var a = new AccountClient(con).BeginGetAccountInfoFromAddress(body =>
{
PublicKey = body.Content.Account.PublicKey ?? throw new Exception("recipient public key cannot be null for encryption");
}, address);
a.AsyncWaitHandle.WaitOne();
if (PublicKey == null)
{
throw new ArgumentNullException("could not find recipient public key");
}
Sender = new PrivateKeyAccountClient(con, senderKey);
MessageBytes = CryptoBytes.FromHexString(Encryption.Encode(MessageString, senderKey, PublicKey));
}
else
{
MessageBytes = Encoding.UTF8.GetBytes(MessageString);
}
PayloadLengthInBytes = MessageBytes.Length;
}
Serialize();
CalculateMessageFee();
}
public void Should_Sign_Data_And_Verify_Signature_SHA3_256()
{
var pk = "A574ECE8F79DE11A39C6BADF0EF87C2C88730A5EA4CF2C0BD7E27103390BC4F4";
var pubKey = "2B0FF0CADE0D945A23D1AF7AF266A0BAB7E07B163756F5F16CC75F24A4EEF23B";
var keyPair = KeyPair.CreateFromPrivateKey(pk);
var message = "This is a test data";
var data = Encoding.UTF8.GetBytes(message);
var encryptedData = CryptoUtils.Sha3_256(data);
var encryptedHex = CryptoBytes.ToHexStringUpper(encryptedData);
var signature = keyPair.Sign(encryptedData);
var sigHex = CryptoBytes.ToHexStringUpper(signature);
var sig2 = CryptoBytes.FromHexString(sigHex);
var publicAccount = PublicAccount.CreateFromPublicKey(pubKey, NetworkType.MIJIN_TEST);
var isValid = publicAccount.VerifySignature(encryptedData, sig2);
isValid.Should().BeTrue();
}