public void ShouldBeModifiable(int repeats)
{
for (int i = 0; i < repeats; i++)
{
PrivateKey key = PrivateKey.CreateKey();
byte[] rndBytes = RndProvider.GetNonZeroBytes(1024);
Payload body = new Payload.Builder()
.Value("rndBytes", rndBytes)
.Build();
Message message = new Message.Builder()
.WithBody(body)
.Build(key);
// serialize & deserialize
Message received = Message.Parse(message.ToBytes());
Assert.True(received.Verify(key.Address));
// verify ok if header changed
received.Headers.Set("timestamp", DateTime.Now);
Assert.True(received.Verify(key.Address));
// verify failed if body changed
received.Body.Set("id", RndProvider.Next(100));
Assert.False(received.Verify(key.Address));
}
}
public void ShouldBeVerifiable(int repeats)
{
for (int i = 0; i < repeats; i++)
{
PrivateKey key = PrivateKey.CreateKey();
PrivateKey wrongKey = key.CKD(key.Bytes);
byte[] rndBytes = RndProvider.GetNonZeroBytes(1024);
Payload body = new Payload.Builder()
.Value("rndBytes", rndBytes)
.Build();
Message message = new Message.Builder()
.WithBody(body)
.Build(key);
// serialize & deserialize
Message received = Message.Parse(message.ToBytes());
Assert.True(received.Verify(key.Address));
Assert.False(received.Verify(wrongKey.Address));
// verify failed if body has changed
received.Body.Set("rndBytes", RndProvider.GetNonZeroBytes(128));
Assert.False(received.Verify(key.Address));
}
}
public async Task <(string key, string error)> GetUserKeyAsync(string token, int id = 0)
{
try
{
PrivateKey nonce = PrivateKey.CreateKey();
(JsonRpc response, string error) = await PostAsync(new JsonRpc.Request(cyprus_getUserKey, id, token, Hex.ToString(nonce.PublicKey.CompressedKey)));
if (ReferenceEquals(response, null))
{
return(null, error);
}
string encrypted = response.Result <string>(0);
string openKey = response.Result <string>(1);
string passKey = nonce.CreateEcdhKey(openKey);
// decrypt user key
return(Aes256.TryDecrypt(Hex.ToByteArray(passKey), Hex.ToByteArray(encrypted), out var plain) ? (Hex.ToString(plain), (string)null) : (null, "can't decrypt key"));
}
catch (Exception ex)
{
return(null, ex.Message);
}
}
public void ShouldBeSerializable(int repeats)
{
for (int i = 0; i < repeats; i++)
{
PrivateKey key = PrivateKey.CreateKey();
byte[] rndBytes = RndProvider.GetNonZeroBytes(1024);
Payload body = new Payload.Builder()
.Value("rndBytes", rndBytes)
.Build();
Message message = new Message.Builder()
.WithBody(body)
.Build(key);
// serialize & deserialize
Message received = Message.Parse(message.ToBytes());
Assert.Equal(message.Hash, received.Hash);
Assert.Equal(rndBytes, message.Value <byte[]>("rndBytes"));
Assert.Equal(rndBytes, received.Value <byte[]>("rndBytes"));
Assert.Equal(message.Value <byte[]>("rndBytes"), received.Value <byte[]>("rndBytes"));
Assert.Equal(message.Headers.Hash, received.Headers.Hash);
Assert.Equal(message.Body.Hash, received.Body.Hash);
}
}
public void Test2()
{
PrivateKey key = PrivateKey.CreateKey();
ElasticLayout layout = ElasticLayout.DefineLayout(1024);
Elastic3D to = new Elastic3D((byte)(1 + RndProvider.Next(layout.X)), (byte)(1 + RndProvider.Next(layout.Y)), (byte)(1 + RndProvider.Next(layout.Z)));
Message message = new Message.Builder()
.Body("rndBytes", RndProvider.GetNonZeroBytes(128))
.Build(key);
PrivateKey routerKey = PrivateKey.CreateKey();
message.RouteTo(to.TimeToLive(), to, layout, routerKey);
Payload routes = message.Routes();
Assert.Equal(to.TimeToLive(), routes.Value <byte>("ttl"));
Assert.Equal(to, routes.Value <Elastic3D>("to"));
Assert.Equal(layout, routes.Value <ElasticLayout>("layout"));
Address router = message.Router();
Assert.Equal(routerKey.Address, router);
Assert.True(message.VerifyRouter());
message.TimeToLive(0);
Assert.Equal(0, message.TimeToLive());
Assert.Equal(0, new Elastic3D(0, 0, 0).TimeToLive());
Assert.Equal(1, new Elastic3D(16, 0, 0).TimeToLive());
Assert.Equal(2, new Elastic3D(13, 15, 0).TimeToLive());
Assert.Equal(3, new Elastic3D(1, 2, 3).TimeToLive());
}
public void ShouldBeParsableElastic3D()
{
PrivateKey messageKey = PrivateKey.CreateKey();
Elastic3D to = new Elastic3D(1, 2, 3);
ElasticLayout layout = new ElasticLayout(16, 16, 16);
Message message = new Message.Builder()
.Body("rndBytes", RndProvider.GetNonZeroBytes(32))
.Build(messageKey);
}
public void DateTimeTest()
{
PrivateKey key = PrivateKey.CreateKey();
Message ping = new Message.Builder()
.Body("rndBytes", RndProvider.GetNonZeroBytes(32))
.Build(key);
Message received = Message.Parse(ping.ToBytes());
Assert.Equal(ping.TimeStamp, received.TimeStamp);
}
public void SignerShouldBeDeterministic()
{
for (int i = 0; i < repeats; i++)
{
H256 messageHash = SecureRandom.GetBytes(H256.BYTE_LENGTH);
PrivateKey privateKey = PrivateKey.CreateKey();
Signature sig1 = privateKey.Sign(messageHash);
Signature sig2 = privateKey.Sign(messageHash);
Assert.Equal(sig1, sig2);
}
}
public void EcdhTest()
{
for (int i = 0; i < repeats; i++)
{
PrivateKey a = PrivateKey.CreateKey();
PrivateKey b = PrivateKey.CreateKey();
string aa = a.PublicKey;
string bb = b.PublicKey;
var expected = a.CreateEcdhKey(bb);
var actual = b.CreateEcdhKey(aa);
Assert.Equal(expected, actual);
}
}
static void Main(string[] args)
{
ILoggable logger = new BLog.Builder()
.WithConsole(true)
.WithFilter(LogFilter.All)
.Build();
PrivateKey key = PrivateKey.CreateKey();
using (CancellationTokenSource cts = new CancellationTokenSource())
{
NodeServer server = new NodeServer(logger);
server.Start(PORT, cts);
Console.CancelKeyPress += (sender, e) =>
{
e.Cancel = true;
cts.Cancel();
};
byte[] rndBytes = RndProvider.GetNonZeroBytes(1024 * 1024);
while (!cts.IsCancellationRequested)
{
Thread.Sleep(10);
rndBytes = RndProvider.GetNonZeroBytes(1024 * 1024);
Message message = new Message.Builder()
.Body("rndBytes", rndBytes)
.Build(key);
byte[] data = message.ToBytes();
// ElasticNode.SendTo(data, "127.0.0.1", PORT);
NodeClient client = new NodeClient(logger);
client.Start("127.0.0.1", PORT);
Thread.Sleep(1000);
// client.Write(data);
client.Stop();
}
}
}
public void SignerShouldRecoverableWithValidRecoverId()
{
for (int i = 0; i < repeats; i++)
{
H256 messageHash = SecureRandom.GetBytes(H256.BYTE_LENGTH);
PrivateKey privateKey = PrivateKey.CreateKey();
Signature sig = privateKey.Sign(messageHash);
Assert.True(sig.V < 4);
Assert.Equal(privateKey.PublicKey, sig.GetPublicKey(messageHash));
byte[] bytes = sig;
bytes[64] = 99;
Signature wrong = Signature.Parse(bytes);
Assert.NotEqual(privateKey.PublicKey, wrong.GetPublicKey(messageHash));
}
}
public void SignerShouldGenerateValidKey()
{
for (int i = 0; i < repeats; i++)
{
H256 messageHash = SecureRandom.GetBytes(H256.BYTE_LENGTH);
PrivateKey secKey = PrivateKey.CreateKey();
PublicKey pubKey = secKey.PublicKey;
Signature sig = secKey.Sign(messageHash);
// private key verify
Assert.True(Secp256k1Helper.SecretKeyVerify(secKey.Key));
// private key, public key, signature length verify
Assert.Equal(PrivateKey.KEY_LENGTH, secKey.Key.Length);
Assert.Equal(PublicKey.KEY_LENGTH, pubKey.Length);
Assert.Equal(Signature.LENGTH, sig.Length);
// verify signature
Assert.True(pubKey.Verify(sig, messageHash));
Assert.Equal(pubKey, sig.GetPublicKey(messageHash));
}
}
private void OnCommandAccountsNew(string[] args)
{
string name = args.Length > 0 ? args[0] : BConsole.ReadLine("name: ");
if (string.IsNullOrEmpty(name))
{
return;
}
if (wallets.Contains(name))
{
BConsole.WriteLine("account name already existing!");
return;
}
string password = BConsole.ReadPassword("password: "******"confirm: ");
if (password != confirm)
{
BConsole.WriteLine("password mismatch");
return;
}
// encrypted key
string keystore = KeyStoreService.EncryptKeyStoreV3(PrivateKey.CreateKey(), password);
var account = wallets.Add(name, keystore);
BConsole.WriteLine("new account(", name, ")! address=", account.Address);
}
public void ShouldBeSerializableObject()
{
Person jade = new Person()
{
id = 100,
name = "JADE KIM",
female = false,
age = 43,
height = 174.5m,
weight = 77.01,
hobby = new string[] { "Basketball", "Movie", "Music" },
birth = new DateTime(1977, 3, 19),
key = PrivateKey.CreateKey().Bytes
};
// serialize & deserialize
Person person = Payload.Parse(
new Payload.Builder(jade)
.Build()
.ToBytes()
).ToObject <Person>();
// assert
Assert.Equal(jade.id, person.id);
Assert.Equal(jade.name, person.name);
Assert.Equal(jade.female, person.female);
Assert.Equal(jade.age, person.age);
Assert.Equal(jade.height, person.height);
Assert.Equal(jade.weight, person.weight);
Assert.Equal(jade.birth, person.birth);
Assert.Equal(jade.key.ToHex(), person.key.ToHex());
Assert.Null(person.context);
for (int i = 0; i < jade.hobby.Length; i++)
{
Assert.Equal(jade.hobby[i], person.hobby[i]);
}
// serialize & deserialize
person = Payload.Parse(
new Payload.Builder()
.Value("person", jade)
.Build()
.ToBytes()
).Value <Person>("person");
// assert
Assert.Equal(jade.id, person.id);
Assert.Equal(jade.name, person.name);
Assert.Equal(jade.female, person.female);
Assert.Equal(jade.age, person.age);
Assert.Equal(jade.height, person.height);
Assert.Equal(jade.weight, person.weight);
Assert.Equal(jade.birth, person.birth);
Assert.Equal(jade.key.ToHex(), person.key.ToHex());
Assert.Null(person.context);
for (int i = 0; i < jade.hobby.Length; i++)
{
Assert.Equal(jade.hobby[i], person.hobby[i]);
}
}
