public void Can_decrypt_auth_message()
{
Hex hex = "048ca79ad18e4b0659fab4853fe5bc58eb83992980f4c9cc147d2aa31532efd29a3d3dc6a3d89eaf" +
"913150cfc777ce0ce4af2758bf4810235f6e6ceccfee1acc6b22c005e9e3a49d6448610a58e98744" +
"ba3ac0399e82692d67c1f58849050b3024e21a52c9d3b01d871ff5f210817912773e610443a9ef14" +
"2e91cdba0bd77b5fdf0769b05671fc35f83d83e4d3b0b000c6b2a1b1bba89e0fc51bf4e460df3105" +
"c444f14be226458940d6061c296350937ffd5e3acaceeaaefd3c6f74be8e23e0f45163cc7ebd7622" +
"0f0128410fd05250273156d548a414444ae2f7dea4dfca2d43c057adb701a715bf59f6fb66b2d1d2" +
"0f2c703f851cbf5ac47396d9ca65b6260bd141ac4d53e2de585a73d1750780db4c9ee4cd4d225173" +
"a4592ee77e2bd94d0be3691f3b406f9bba9b591fc63facc016bfa8";
byte[] deciphered = _eciesCipher.Decrypt(NetTestVectors.StaticKeyB, hex);
AuthMessage authMessage = _messageSerializationService.Deserialize <AuthMessage>(deciphered);
Assert.AreEqual(authMessage.PublicKey, NetTestVectors.StaticKeyA.PublicKey);
Assert.AreEqual(authMessage.EphemeralPublicHash, Keccak.Compute(NetTestVectors.EphemeralKeyA.PublicKey.Bytes));
Assert.AreEqual(authMessage.Nonce, NetTestVectors.NonceA);
Assert.AreEqual(authMessage.IsTokenUsed, false);
Assert.NotNull(authMessage.Signature);
byte[] data = _messageSerializationService.Serialize(authMessage);
Array.Resize(ref data, deciphered.Length);
Assert.AreEqual(deciphered, data, "serialization");
}
public void PingMessageTest()
{
var message = new PingMessage
{
FarAddress = _farAddress,
DestinationAddress = _nearAddress,
SourceAddress = _farAddress,
FarPublicKey = _privateKey.PublicKey,
ExpirationTime = 60 + (long)_timestamper.EpochMilliseconds
};
var data = _messageSerializationService.Serialize(message);
var deserializedMessage = _messageSerializationService.Deserialize <PingMessage>(data);
Assert.AreEqual(message.MessageType, deserializedMessage.MessageType);
Assert.AreEqual(message.FarPublicKey, deserializedMessage.FarPublicKey);
Assert.AreEqual(message.ExpirationTime, deserializedMessage.ExpirationTime);
Assert.AreEqual(message.FarAddress, deserializedMessage.SourceAddress);
Assert.AreEqual(message.DestinationAddress, deserializedMessage.DestinationAddress);
Assert.AreEqual(message.SourceAddress, deserializedMessage.SourceAddress);
Assert.AreEqual(message.Version, deserializedMessage.Version);
byte[] expectedPingMdc = Bytes.FromHexString("0xf8c61953f3b94a91aefe611e61dd74fe26aa5c969d9f29b7e063e6169171a772");
Assert.IsNotNull(expectedPingMdc);
}
public void PingMessageTest()
{
var message = new PingMessage
{
FarAddress = _farAddress,
DestinationAddress = _nearAddress,
SourceAddress = _farAddress,
Version = _config.PingMessageVersion,
FarPublicKey = _privateKey.PublicKey,
ExpirationTime = 60 + (long)_timestamper.EpochMilliseconds
};
var data = _messageSerializationService.Serialize(message);
var deserializedMessage = _messageSerializationService.Deserialize <PingMessage>(data);
Assert.AreEqual(message.MessageType, deserializedMessage.MessageType);
Assert.AreEqual(message.FarPublicKey, deserializedMessage.FarPublicKey);
Assert.AreEqual(message.ExpirationTime, deserializedMessage.ExpirationTime);
Assert.AreEqual(message.FarAddress, deserializedMessage.SourceAddress);
Assert.AreEqual(message.DestinationAddress, deserializedMessage.DestinationAddress);
Assert.AreEqual(message.SourceAddress, deserializedMessage.SourceAddress);
Assert.AreEqual(message.Version, deserializedMessage.Version);
Assert.IsNotNull(deserializedMessage.Mdc);
}
public Packet Auth(PublicKey remoteNodeId, EncryptionHandshake handshake)
{
handshake.RemoteNodeId = remoteNodeId;
handshake.InitiatorNonce = _cryptoRandom.GenerateRandomBytes(32);
handshake.EphemeralPrivateKey = _ephemeralGenerator.Generate();
byte[] staticSharedSecret = Proxy.EcdhSerialized(remoteNodeId.Bytes, _privateKey.KeyBytes);
byte[] forSigning = staticSharedSecret.Xor(handshake.InitiatorNonce);
AuthEip8Message authMessage = new AuthEip8Message();
authMessage.Nonce = handshake.InitiatorNonce;
authMessage.PublicKey = _privateKey.PublicKey;
authMessage.Signature = _ecdsa.Sign(handshake.EphemeralPrivateKey, new Keccak(forSigning));
byte[] authData = _messageSerializationService.Serialize(authMessage);
int size = authData.Length + 32 + 16 + 65; // data + MAC + IV + pub
byte[] sizeBytes = size.ToBigEndianByteArray().Slice(2, 2);
byte[] packetData = _eciesCipher.Encrypt(
remoteNodeId,
authData,
sizeBytes);
handshake.AuthPacket = new Packet(Bytes.Concat(sizeBytes, packetData));
return(handshake.AuthPacket);
}
public void PingMessageTest()
{
var message = new PingMessage
{
FarAddress = _farAddress,
DestinationAddress = _nearAddress,
SourceAddress = _farAddress,
Version = _config.PingMessageVersion,
FarPublicKey = _privateKey.PublicKey,
ExpirationTime = _config.DiscoveryMsgExpiryTime + Timestamp.UnixUtcUntilNowMilisecs
};
var data = _messageSerializationService.Serialize(message);
var deserializedMessage = _messageSerializationService.Deserialize <PingMessage>(data);
Assert.AreEqual(message.MessageType, deserializedMessage.MessageType);
Assert.AreEqual(message.FarPublicKey, deserializedMessage.FarPublicKey);
Assert.AreEqual(message.ExpirationTime, deserializedMessage.ExpirationTime);
Assert.AreEqual(message.FarAddress, deserializedMessage.SourceAddress);
Assert.AreEqual(message.DestinationAddress, deserializedMessage.DestinationAddress);
Assert.AreEqual(message.SourceAddress, deserializedMessage.SourceAddress);
Assert.AreEqual(message.Version, deserializedMessage.Version);
Assert.IsNotNull(deserializedMessage.Mdc);
}
public void handling_hi_message_should_succeed()
{
_verifySignature = true;
InitSubprotocol();
var hiMessage = new HiMessage(1, TestItem.AddressC, TestItem.AddressD, TestItem.PublicKeyA,
new Signature(1, 1, 27));
var hiPacket = new Packet(hiMessage.Protocol, hiMessage.PacketType,
_messageSerializationService.Serialize(hiMessage));
_messageSerializationService.Deserialize <HiMessage>(hiPacket.Data).Returns(hiMessage);
var hash = Keccak.Compute(hiMessage.NodeId.Bytes);
_ecdsa.RecoverPublicKey(hiMessage.Signature, hash).Returns(TestItem.PublicKeyA);
_subprotocol.HandleMessage(hiPacket);
_ecdsa.Received().RecoverPublicKey(hiMessage.Signature, hash);
_subprotocol.ProviderAddress.Should().Be(hiMessage.ProviderAddress);
_subprotocol.ConsumerAddress.Should().Be(hiMessage.ConsumerAddress);
_consumerService.Received().AddProviderPeer(_subprotocol);
var getDataAssetsMessage = new GetDataAssetsMessage();
_messageSerializationService.Serialize(getDataAssetsMessage).Returns(Array.Empty <byte>());
var getDataAssetsPacket = new Packet(getDataAssetsMessage.Protocol, getDataAssetsMessage.PacketType,
_messageSerializationService.Serialize(getDataAssetsMessage));
_messageSerializationService.Deserialize <GetDataAssetsMessage>(getDataAssetsPacket.Data)
.Returns(getDataAssetsMessage);
Received.InOrder(() =>
{
_session.DeliverMessage(Arg.Any <GetDataAssetsMessage>());
_session.DeliverMessage(Arg.Any <GetDepositApprovalsMessage>());
});
}
public void TestBeforeHi <T>(T message) where T : P2PMessage
{
BuildSubprotocol();
byte[] bytes = _service.Serialize(message);
Packet packet = new Packet(bytes);
packet.PacketType = message.PacketType;
Assert.Throws <SubprotocolException>(() => _subprotocol.HandleMessage(packet));
}
private void Test <T>(T message) where T : P2PMessage
{
message.Protocol.Should().Be("ndm");
FieldInfo fieldInfo = typeof(NdmMessageCode).GetField(message.GetType().Name.Replace("Message", string.Empty), BindingFlags.Static | BindingFlags.Public);
message.PacketType.Should().Be((int)fieldInfo.GetValue(null));
byte[] firstSer = _service.Serialize(message);
byte[] secondSer = _service.Serialize(_service.Deserialize <T>(firstSer));
firstSer.Should().BeEquivalentTo(secondSer, typeof(T).Name + " -> " + firstSer.ToHexString());
}
public void Enqueue <T>(T message) where T : P2PMessage
{
if (!_context.Channel.Active)
{
return;
}
IByteBuffer buffer = PooledByteBufferAllocator.Default.Buffer(512);
buffer.WriteByte(message.AdaptivePacketType);
_messageSerializationService.Serialize(message, buffer);
_context.WriteAndFlushAsync(buffer).ContinueWith(t =>
{
if (t.IsFaulted)
{
if (_context.Channel != null && !_context.Channel.Active)
{
if (_logger.IsTrace)
{
_logger.Trace($"Channel is not active - {t.Exception.Message}");
}
}
else if (_logger.IsError)
{
_logger.Error("Channel is active", t.Exception);
}
}
else if (t.IsCompleted)
{
// if (_logger.IsTrace) _logger.Trace($"Packet ({packet.Protocol}.{packet.PacketType}) pushed");
}
});
}
protected void Send <T>(T message) where T : P2PMessage
{
if (Logger.IsTrace)
{
Logger.Trace($"Sending {typeof(T).Name}");
}
Packet packet = new Packet(message.Protocol, message.PacketType, _serializer.Serialize(message));
P2PSession.DeliverMessage(packet);
}
private byte[] Seserialize(DiscoveryMessage message)
{
switch (message.MessageType)
{
case MessageType.Ping:
return(_messageSerializationService.Serialize((PingMessage)message));
case MessageType.Pong:
return(_messageSerializationService.Serialize((PongMessage)message));
case MessageType.FindNode:
return(_messageSerializationService.Serialize((FindNodeMessage)message));
case MessageType.Neighbors:
return(_messageSerializationService.Serialize((NeighborsMessage)message));
default:
throw new Exception($"Unsupported messageType: {message.MessageType}");
}
}
public void SendNewCapability(Capability capability)
{
var message = new AddCapabilityMessage(capability);
var packet = new Packet(Protocol.P2P, P2PMessageCode.AddCapability, _serializer.Serialize(message));
foreach (var(_, session) in _sessions)
{
if (session.HasAgreedCapability(capability))
{
continue;
}
if (!session.HasAvailableCapability(capability))
{
continue;
}
session.DeliverMessage(packet);
}
}
public Context ReceiveDisconnect()
{
DisconnectMessage message = new DisconnectMessage(DisconnectReason.Other);
_currentSession.ReceiveMessage(new Packet("p2p", P2PMessageCode.Disconnect, _serializer.Serialize(message)));
return(this);
}
private Packet CreatePacket(P2PMessage message)
{
return(new Packet(message.Protocol, message.PacketType, _serializer.Serialize(message)));
}
