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>()); }); }
protected T Deserialize <T>(byte[] data) where T : P2PMessage { try { return(_serializer.Deserialize <T>(data)); } catch (RlpException e) { if (Logger.IsDebug) { Logger.Debug($"Failed to deserialize message {typeof(T).Name}, with exception {e}"); } ReportIn($"{typeof(T).Name} - Deserialization exception"); throw; } }
private DiscoveryMessage Deserialize(MessageType type, byte[] msg) { switch (type) { case MessageType.Ping: return(_messageSerializationService.Deserialize <PingMessage>(msg)); case MessageType.Pong: return(_messageSerializationService.Deserialize <PongMessage>(msg)); case MessageType.FindNode: return(_messageSerializationService.Deserialize <FindNodeMessage>(msg)); case MessageType.Neighbors: return(_messageSerializationService.Deserialize <NeighborsMessage>(msg)); default: throw new Exception($"Unsupported messageType: {type}"); } }
public void PingFormatTest() { var encodedPing = "e9614ccfd9fc3e74360018522d30e1419a143407ffcce748de3e22116b7e8dc92ff74788c0b6663a" + "aa3d67d641936511c8f8d6ad8698b820a7cf9e1be7155e9a241f556658c55428ec0563514365799a" + "4be2be5a685a80971ddcfa80cb422cdd0101ec04cb847f000001820cfa8215a8d790000000000000" + "000000000000000000018208ae820d058443b9a3550102"; var ping = _messageSerializationService.Deserialize <PingMessage>(Bytes.FromHexString(encodedPing)); Assert.AreEqual(4, ping.Version); encodedPing = "577be4349c4dd26768081f58de4c6f375a7a22f3f7adda654d1428637412c3d7fe917cadc56d4e5e" + "7ffae1dbe3efffb9849feb71b262de37977e7c7a44e677295680e9e38ab26bee2fcbae207fba3ff3" + "d74069a50b902a82c9903ed37cc993c50001f83e82022bd79020010db83c4d001500000000abcdef" + "12820cfa8215a8d79020010db885a308d313198a2e037073488208ae82823a8443b9a355c5010203" + "040531b9019afde696e582a78fa8d95ea13ce3297d4afb8ba6433e4154caa5ac6431af1b80ba7602" + "3fa4090c408f6b4bc3701562c031041d4702971d102c9ab7fa5eed4cd6bab8f7af956f7d565ee191" + "7084a95398b6a21eac920fe3dd1345ec0a7ef39367ee69ddf092cbfe5b93e5e568ebc491983c09c7" + "6d922dc3"; ping = _messageSerializationService.Deserialize <PingMessage>(Bytes.FromHexString(encodedPing)); Assert.AreEqual(555, ping.Version); }
public void Can_decrypt_auth_eip8_message_with_additional_elements() { Hex hex = "01b8044c6c312173685d1edd268aa95e1d495474c6959bcdd10067ba4c9013df9e40ff45f5bfd6f7" + "2471f93a91b493f8e00abc4b80f682973de715d77ba3a005a242eb859f9a211d93a347fa64b597bf" + "280a6b88e26299cf263b01b8dfdb712278464fd1c25840b995e84d367d743f66c0e54a586725b7bb" + "f12acca27170ae3283c1073adda4b6d79f27656993aefccf16e0d0409fe07db2dc398a1b7e8ee93b" + "cd181485fd332f381d6a050fba4c7641a5112ac1b0b61168d20f01b479e19adf7fdbfa0905f63352" + "bfc7e23cf3357657455119d879c78d3cf8c8c06375f3f7d4861aa02a122467e069acaf513025ff19" + "6641f6d2810ce493f51bee9c966b15c5043505350392b57645385a18c78f14669cc4d960446c1757" + "1b7c5d725021babbcd786957f3d17089c084907bda22c2b2675b4378b114c601d858802a55345a15" + "116bc61da4193996187ed70d16730e9ae6b3bb8787ebcaea1871d850997ddc08b4f4ea668fbf3740" + "7ac044b55be0908ecb94d4ed172ece66fd31bfdadf2b97a8bc690163ee11f5b575a4b44e36e2bfb2" + "f0fce91676fd64c7773bac6a003f481fddd0bae0a1f31aa27504e2a533af4cef3b623f4791b2cca6" + "d490"; byte[] allBytes = hex; byte[] sizeBytes = allBytes.Slice(0, 2); int size = sizeBytes.ToInt32(); byte[] deciphered = _eciesCipher.Decrypt(NetTestVectors.StaticKeyB, allBytes.Slice(2, size), sizeBytes); AuthEip8Message authMessage = _messageSerializationService.Deserialize <AuthEip8Message>(deciphered); Assert.AreEqual(authMessage.PublicKey, NetTestVectors.StaticKeyA.PublicKey); Assert.AreEqual(authMessage.Nonce, NetTestVectors.NonceA); Assert.AreEqual(authMessage.Version, 4); Assert.NotNull(authMessage.Signature); }
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 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); }
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 Packet Ack(EncryptionHandshake handshake, Packet auth) { handshake.AuthPacket = auth; AuthMessageBase authMessage; bool preEip8Format = false; byte[] plainText = null; try { if (_logger.IsTrace) { _logger.Trace($"Trying to decrypt an old version of {nameof(AuthMessage)}"); } (preEip8Format, plainText) = _eciesCipher.Decrypt(_privateKey, auth.Data); } catch (Exception ex) { if (_logger.IsTrace) { _logger.Trace($"Exception when decrypting ack {ex.Message}"); } } if (preEip8Format) { authMessage = _messageSerializationService.Deserialize <AuthMessage>(plainText); } else { if (_logger.IsTrace) { _logger.Trace($"Trying to decrypt version 4 of {nameof(AuthEip8Message)}"); } byte[] sizeData = auth.Data.Slice(0, 2); (_, plainText) = _eciesCipher.Decrypt(_privateKey, auth.Data.Slice(2), sizeData); authMessage = _messageSerializationService.Deserialize <AuthEip8Message>(plainText); } var nodeId = authMessage.PublicKey; if (_logger.IsTrace) { _logger.Trace($"Received AUTH v{authMessage.Version} from {nodeId}"); } handshake.RemoteNodeId = nodeId; handshake.RecipientNonce = _cryptoRandom.GenerateRandomBytes(32); handshake.EphemeralPrivateKey = _ephemeralGenerator.Generate(); handshake.InitiatorNonce = authMessage.Nonce; byte[] staticSharedSecret = Proxy.EcdhSerialized(handshake.RemoteNodeId.Bytes, _privateKey.KeyBytes); byte[] forSigning = staticSharedSecret.Xor(handshake.InitiatorNonce); handshake.RemoteEphemeralPublicKey = _ecdsa.RecoverPublicKey(authMessage.Signature, new Keccak(forSigning)); byte[] data; if (preEip8Format) { if (_logger.IsTrace) { _logger.Trace($"Building an {nameof(AckMessage)}"); } AckMessage ackMessage = new AckMessage(); ackMessage.EphemeralPublicKey = handshake.EphemeralPrivateKey.PublicKey; ackMessage.Nonce = handshake.RecipientNonce; var ackData = _messageSerializationService.Serialize(ackMessage); data = _eciesCipher.Encrypt(handshake.RemoteNodeId, ackData, Array.Empty <byte>()); } else { if (_logger.IsTrace) { _logger.Trace($"Building an {nameof(AckEip8Message)}"); } AckEip8Message ackMessage = new AckEip8Message(); ackMessage.EphemeralPublicKey = handshake.EphemeralPrivateKey.PublicKey; ackMessage.Nonce = handshake.RecipientNonce; var ackData = _messageSerializationService.Serialize(ackMessage); int size = ackData.Length + 32 + 16 + 65; // data + MAC + IV + pub byte[] sizeBytes = size.ToBigEndianByteArray().Slice(2, 2); data = Bytes.Concat(sizeBytes, _eciesCipher.Encrypt(handshake.RemoteNodeId, ackData, sizeBytes)); } handshake.AckPacket = new Packet(data); SetSecrets(handshake, HandshakeRole.Recipient); return(handshake.AckPacket); }
protected T Deserialize <T>(byte[] data) where T : P2PMessage { return(_serializer.Deserialize <T>(data)); }
public Packet Ack(EncryptionHandshake handshake, Packet auth) { handshake.AuthPacket = auth; AuthMessageBase authMessage; bool isOld = false; try { _logger.Info($"Trying to decrypt an old version of {nameof(AuthMessage)}"); byte[] plaintextOld = _eciesCipher.Decrypt(_privateKey, auth.Data); authMessage = _messageSerializationService.Deserialize <AuthMessage>(plaintextOld); isOld = true; } catch (Exception) { _logger.Info($"Trying to decrypt version 4 of {nameof(AuthEip8Message)}"); byte[] sizeData = auth.Data.Slice(0, 2); byte[] plaintext = _eciesCipher.Decrypt(_privateKey, auth.Data.Slice(2), sizeData); authMessage = _messageSerializationService.Deserialize <AuthEip8Message>(plaintext); } var nodeId = new NodeId(authMessage.PublicKey); _logger.Debug($"Received AUTH v{authMessage.Version} from {nodeId}"); handshake.RemoteNodeId = nodeId; handshake.RecipientNonce = _cryptoRandom.GenerateRandomBytes(32); handshake.EphemeralPrivateKey = new PrivateKey(_cryptoRandom.GenerateRandomBytes(32)); handshake.InitiatorNonce = authMessage.Nonce; byte[] staticSharedSecret = BouncyCrypto.Agree(_privateKey, handshake.RemoteNodeId.PublicKey); byte[] forSigning = staticSharedSecret.Xor(handshake.InitiatorNonce); handshake.RemoteEphemeralPublicKey = _signer.RecoverPublicKey(authMessage.Signature, new Keccak(forSigning)); byte[] ackData; if (isOld) // what was the difference? shall I really include ephemeral public key in v4? { _logger.Debug($"Building an {nameof(AckMessage)}"); AckMessage ackMessage = new AckMessage(); ackMessage.EphemeralPublicKey = handshake.EphemeralPrivateKey.PublicKey; ackMessage.Nonce = handshake.RecipientNonce; ackData = _messageSerializationService.Serialize(ackMessage); } else { _logger.Debug($"Building an {nameof(AckEip8Message)}"); AckEip8Message ackMessage = new AckEip8Message(); ackMessage.EphemeralPublicKey = handshake.EphemeralPrivateKey.PublicKey; ackMessage.Nonce = handshake.RecipientNonce; ackData = _messageSerializationService.Serialize(ackMessage); } int size = ackData.Length + 32 + 16 + 65; // data + MAC + IV + pub byte[] sizeBytes = size.ToBigEndianByteArray().Slice(2, 2); byte[] packetData = _eciesCipher.Encrypt(handshake.RemoteNodeId.PublicKey, ackData, sizeBytes); handshake.AckPacket = new Packet(Bytes.Concat(sizeBytes, packetData)); SetSecrets(handshake, EncryptionHandshakeRole.Recipient); return(handshake.AckPacket); }