Updating host ENR (#5593)

Updating host ENR

Author: gumb0

CHANGELOG.md

@@ -9,6 +9,7 @@
 - Added: [#5575](https://github.com/ethereum/aleth/pull/5575) Log active peer count and peer list every 30 seconds.
 - Added: [#5580](https://github.com/ethereum/aleth/pull/5580) Enable syncing from ETC nodes for blocks < dao hard fork block.
 - Added: [#5591](https://github.com/ethereum/aleth/pull/5591) Network logging bugfixes and improvements and add p2pcap log channel.
+- Added: [#5593](https://github.com/ethereum/aleth/pull/5593) Dynamically updating host ENR.
 - Changed: [#5559](https://github.com/ethereum/aleth/pull/5559) Update peer validation error messages.
 - Changed: [#5568](https://github.com/ethereum/aleth/pull/5568) Improve rlpx handshake log messages and create new rlpx log channel.
 - Changed: [#5576](https://github.com/ethereum/aleth/pull/5576) Moved sstore_combinations and static_Call50000_sha256 tests to stTimeConsuming test suite. (testeth runs them only with `--all` flag)

libp2p/ENR.cpp

@@ -12,7 +12,7 @@ namespace p2p
 namespace
 {
 constexpr char c_keyID[] = "id";
-constexpr char c_keySec256k1[] = "secp256k1";
+constexpr char c_keySecp256k1[] = "secp256k1";
 constexpr char c_keyIP[] = "ip";
 constexpr char c_keyTCP[] = "tcp";
 constexpr char c_keyUDP[] = "udp";
@@ -27,6 +27,14 @@ bytes addressToBytes(Address const& _address)
     auto const addressBytes = _address.to_bytes();
     return bytes(addressBytes.begin(), addressBytes.end());
 }
+
+template <std::size_t N>
+std::array<byte, N> bytesToAddress(bytesConstRef _bytes)
+{
+    std::array<byte, N> address;
+    std::copy_n(_bytes.begin(), N, address.begin());
+    return address;
+}
 }  // namespace
 
 ENR::ENR(RLP const& _rlp, VerifyFunction const& _verifyFunction)
@@ -48,18 +56,18 @@ ENR::ENR(RLP const& _rlp, VerifyFunction const& _verifyFunction)
     }
 
     // transfer to map, this will order them
-    m_map.insert(keyValuePairs.begin(), keyValuePairs.end());
+    m_keyValuePairs.insert(keyValuePairs.begin(), keyValuePairs.end());
 
-    if (!std::equal(keyValuePairs.begin(), keyValuePairs.end(), m_map.begin()))
+    if (!std::equal(keyValuePairs.begin(), keyValuePairs.end(), m_keyValuePairs.begin()))
         BOOST_THROW_EXCEPTION(ENRKeysAreNotUniqueSorted());
 
-    if (!_verifyFunction(m_map, dev::ref(m_signature), dev::ref(content())))
+    if (!_verifyFunction(m_keyValuePairs, dev::ref(m_signature), dev::ref(content())))
         BOOST_THROW_EXCEPTION(ENRSignatureIsInvalid());
 }
 
 ENR::ENR(uint64_t _seq, std::map<std::string, bytes> const& _keyValuePairs,
     SignFunction const& _signFunction)
-  : m_seq{_seq}, m_map{_keyValuePairs}, m_signature{_signFunction(dev::ref(content()))}
+  : m_seq{_seq}, m_keyValuePairs{_keyValuePairs}, m_signature{_signFunction(dev::ref(content()))}
 {
 }
 
@@ -81,36 +89,99 @@ void ENR::streamRLP(RLPStream& _s) const
 void ENR::streamContent(RLPStream& _s) const
 {
     _s << m_seq;
-    for (auto const& keyValue : m_map)
+    for (auto const& keyValue : m_keyValuePairs)
     {
         _s << keyValue.first;
         _s.appendRaw(keyValue.second);
     }
 }
 
-ENR createV4ENR(Secret const& _secret, boost::asio::ip::address const& _ip, uint16_t _tcpPort,  uint16_t _udpPort)
+ENR ENR::update(
+    std::map<std::string, bytes> const& _keyValuePairs, SignFunction const& _signFunction) const
 {
-    ENR::SignFunction signFunction = [&_secret](bytesConstRef _data) {
-        // dev::sign returns 65 bytes signature containing r,s,v values
-        Signature s = dev::sign(_secret, sha3(_data)); 
-        // The resulting 64-byte signature is encoded as the concatenation of the r and s signature values.
-        return bytes(&s[0], &s[64]);
-    };
+    return ENR{m_seq + 1, _keyValuePairs, _signFunction};
+}
+
+std::string ENR::id() const
+{
+    auto itID = m_keyValuePairs.find(c_keyID);
+    return itID == m_keyValuePairs.end() ? "" : RLP(itID->second).toString(RLP::VeryStrict);
+}
+
+boost::asio::ip::address ENR::ip() const
+{
+    auto itIP = m_keyValuePairs.find(c_keyIP);
+    if (itIP == m_keyValuePairs.end())
+        return {};
+
+    auto rlpAddress = RLP{itIP->second};
+    auto const addressBytes = rlpAddress.toBytesConstRef();
+
+    if (rlpAddress.size() == 4)
+        return ba::ip::address_v4{bytesToAddress<4>(addressBytes)};
+    else if (rlpAddress.size() == 16)
+        return ba::ip::address_v6{bytesToAddress<16>(addressBytes)};
+    else
+        BOOST_THROW_EXCEPTION(ENRUnsupportedIPAddress());
+}
 
+uint16_t ENR::tcpPort() const
+{
+    auto itTCP = m_keyValuePairs.find(c_keyTCP);
+    return itTCP == m_keyValuePairs.end() ? 0 : RLP{itTCP->second}.toInt<uint16_t>(RLP::VeryStrict);
+}
+
+uint16_t ENR::udpPort() const
+{
+    auto itUDP = m_keyValuePairs.find(c_keyUDP);
+    return itUDP == m_keyValuePairs.end() ? 0 : RLP{itUDP->second}.toInt<uint16_t>(RLP::VeryStrict);
+}
+
+ENR IdentitySchemeV4::createENR(Secret const& _secret, boost::asio::ip::address const& _ip,
+    uint16_t _tcpPort, uint16_t _udpPort)
+{
+    ENR::SignFunction signFunction = [&_secret](
+                                         bytesConstRef _data) { return sign(_data, _secret); };
+
+    auto const keyValuePairs = createKeyValuePairs(_secret, _ip, _tcpPort, _udpPort);
+
+    return ENR{1 /* sequence number */, keyValuePairs, signFunction};
+}
+
+bytes IdentitySchemeV4::sign(bytesConstRef _data, Secret const& _secret)
+{
+    // dev::sign returns 65 bytes signature containing r,s,v values
+    Signature s = dev::sign(_secret, sha3(_data));
+    // The resulting 64-byte signature is encoded as the concatenation of the r and s signature
+    // values.
+    return bytes(&s[0], &s[64]);
+}
+
+std::map<std::string, bytes> IdentitySchemeV4::createKeyValuePairs(Secret const& _secret,
+    boost::asio::ip::address const& _ip, uint16_t _tcpPort, uint16_t _udpPort)
+{
     PublicCompressed const publicKey = toPublicCompressed(_secret);
 
     auto const address = _ip.is_v4() ? addressToBytes(_ip.to_v4()) : addressToBytes(_ip.to_v6());
 
     // Values are of different types (string, bytes, uint16_t),
     // so we store them as RLP representation
-    std::map<std::string, bytes> const keyValuePairs = {{c_keyID, rlp(c_IDV4)},
-        {c_keySec256k1, rlp(publicKey.asBytes())}, {c_keyIP, rlp(address)},
-        {c_keyTCP, rlp(_tcpPort)}, {c_keyUDP, rlp(_udpPort)}};
+    return {{c_keyID, rlp(c_IDV4)}, {c_keySecp256k1, rlp(publicKey.asBytes())},
+        {c_keyIP, rlp(address)}, {c_keyTCP, rlp(_tcpPort)}, {c_keyUDP, rlp(_udpPort)}};
+}
+
+ENR IdentitySchemeV4::updateENR(ENR const& _enr, Secret const& _secret,
+    boost::asio::ip::address const& _ip, uint16_t _tcpPort, uint16_t _udpPort)
+{
+    ENR::SignFunction signFunction = [&_secret](
+                                         bytesConstRef _data) { return sign(_data, _secret); };
 
-    return ENR{0 /* sequence number */, keyValuePairs, signFunction};
+    auto const keyValuePairs = createKeyValuePairs(_secret, _ip, _tcpPort, _udpPort);
+
+    return _enr.update(keyValuePairs, signFunction);
 }
 
-ENR parseV4ENR(RLP const& _rlp)
+ENR IdentitySchemeV4::parseENR(RLP const& _rlp)
 {
     ENR::VerifyFunction verifyFunction = [](std::map<std::string, bytes> const& _keyValuePairs,
                                              bytesConstRef _signature, bytesConstRef _data) {
@@ -121,7 +192,7 @@ ENR parseV4ENR(RLP const& _rlp)
         if (id != c_IDV4)
             return false;
 
-        auto itKey = _keyValuePairs.find(c_keySec256k1);
+        auto itKey = _keyValuePairs.find(c_keySecp256k1);
         if (itKey == _keyValuePairs.end())
             return false;
 
@@ -134,15 +205,47 @@ ENR parseV4ENR(RLP const& _rlp)
     return ENR{_rlp, verifyFunction};
 }
 
+PublicCompressed IdentitySchemeV4::publicKey(ENR const& _enr)
+{
+    auto const& keyValuePairs = _enr.keyValuePairs();
+
+    auto itID = keyValuePairs.find(c_keyID);
+    if (itID == keyValuePairs.end() || RLP(itID->second).toString(RLP::VeryStrict) != c_IDV4)
+        BOOST_THROW_EXCEPTION(ENRUnknownIdentityScheme());
+
+    auto itKey = keyValuePairs.find(c_keySecp256k1);
+    if (itKey == keyValuePairs.end())
+        BOOST_THROW_EXCEPTION(ENRSecp256k1NotFound());
+
+    return RLP{itKey->second}.toHash<PublicCompressed>();
+}
+
 std::ostream& operator<<(std::ostream& _out, ENR const& _enr)
 {
-    _out << "[ " << toHexPrefixed(_enr.signature()) << " seq=" << _enr.sequenceNumber() << " ";
-    for (auto const& keyValue : _enr.keyValuePairs())
+    _out << "[ seq=" << _enr.sequenceNumber() << " "
+         << "id=" << _enr.id() << " ";
+
+    try
     {
-        _out << keyValue.first << "=";
-        _out << toHexPrefixed(RLP{keyValue.second}.toBytes()) << " ";
+        auto const pubKey = IdentitySchemeV4::publicKey(_enr);
+        auto const address = _enr.ip();
+        auto const tcp = _enr.tcpPort();
+        auto const udp = _enr.udpPort();
+
+        _out << "key=" << pubKey.abridged() << " ip=" << address << " tcp=" << tcp
+             << " udp=" << udp;
     }
-    _out << "]";
+    catch (Exception const&)
+    {
+        // If failed to get V4 fields, just dump all values
+        for (auto const& keyValue : _enr.keyValuePairs())
+        {
+            _out << keyValue.first << "=";
+            _out << toHexPrefixed(RLP{keyValue.second}.toBytes()) << " ";
+        }
+    }
+
+    _out << " ]";
     return _out;
 }
 

libp2p/ENR.h

@@ -13,6 +13,9 @@ namespace p2p
 DEV_SIMPLE_EXCEPTION(ENRIsTooBig);
 DEV_SIMPLE_EXCEPTION(ENRSignatureIsInvalid);
 DEV_SIMPLE_EXCEPTION(ENRKeysAreNotUniqueSorted);
+DEV_SIMPLE_EXCEPTION(ENRUnknownIdentityScheme);
+DEV_SIMPLE_EXCEPTION(ENRSecp256k1NotFound);
+DEV_SIMPLE_EXCEPTION(ENRUnsupportedIPAddress);
 
 /// Class representing Ethereum Node Record - see EIP-778
 class ENR
@@ -21,40 +24,65 @@ class ENR
     // ENR class implementation is independent of Identity Scheme.
     // Identity Scheme specifics are passed to ENR as functions.
 
-    // Sign function gets serialized ENR contents and signs it according to some Identity Scheme
+    /// Sign function gets serialized ENR contents and signs it according to some Identity Scheme
     using SignFunction = std::function<bytes(bytesConstRef)>;
-    // Verify function gets ENR key-value pairs, signature, and serialized content and validates the
-    // signature according to some Identity Scheme
+    /// Verify function gets ENR key-value pairs, signature, and serialized content and validates the
+    /// signature according to some Identity Scheme
     using VerifyFunction =
         std::function<bool(std::map<std::string, bytes> const&, bytesConstRef, bytesConstRef)>;
 
-    // Parse from RLP with given signature verification function
+    /// Parse from RLP with given signature verification function
     ENR(RLP const& _rlp, VerifyFunction const& _verifyFunction);
-    // Create with given sign function
-    ENR(uint64_t _seq, std::map<std::string, bytes> const& _keyValues,
+    /// Create with given sign function
+    ENR(uint64_t _seq, std::map<std::string, bytes> const& _keyValuePairs,
         SignFunction const& _signFunction);
 
     uint64_t sequenceNumber() const { return m_seq; }
-    std::map<std::string, bytes> const& keyValuePairs() const { return m_map; }
     bytes const& signature() const { return m_signature; }
 
-    // Serialize to given RLP stream
+    std::map<std::string, bytes> const& keyValuePairs() const { return m_keyValuePairs; }
+
+    /// Pre-defined keys
+    std::string id() const;
+    boost::asio::ip::address ip() const;
+    uint16_t tcpPort() const;
+    uint16_t udpPort() const;
+
+    /// Serialize to given RLP stream
     void streamRLP(RLPStream& _s) const;
 
+    /// Create new ENR succeeding current one with updated @a _keyValuePairs
+    ENR update(
+        std::map<std::string, bytes> const& _keyValuePair, SignFunction const& _signFunction) const;
+
 private:
     uint64_t m_seq = 0;
-    std::map<std::string, bytes> m_map;
+    std::map<std::string, bytes> m_keyValuePairs;
     bytes m_signature;
 
     bytes content() const;
-    size_t contentRlpListItemCount() const { return m_map.size() * 2 + 1; }
+    size_t contentRlpListItemCount() const { return m_keyValuePairs.size() * 2 + 1; }
     void streamContent(RLPStream& _s) const;
 };
 
+class IdentitySchemeV4
+{
+public:
+    static ENR createENR(Secret const& _secret, boost::asio::ip::address const& _ip,
+        uint16_t _tcpPort, uint16_t _udpPort);
 
-ENR createV4ENR(Secret const& _secret, boost::asio::ip::address const& _ip, uint16_t _tcpPort,  uint16_t _udpPort);
+    static ENR updateENR(ENR const& _enr, Secret const& _secret,
+        boost::asio::ip::address const& _ip, uint16_t _tcpPort, uint16_t _udpPort);
 
-ENR parseV4ENR(RLP const& _rlp);
+    static ENR parseENR(RLP const& _rlp);
+
+    static PublicCompressed publicKey(ENR const& _enr);
+
+private:
+    static bytes sign(bytesConstRef _data, Secret const& _secret);
+    static std::map<std::string, bytes> createKeyValuePairs(Secret const& _secret,
+        boost::asio::ip::address const& _ip, uint16_t _tcpPort, uint16_t _udpPort);
+};
 
 std::ostream& operator<<(std::ostream& _out, ENR const& _enr);