Reimplement EthereumNodeRecord for DNS discovery (#7989)

* Reimplement EthereumNodeRecord and remove dependency on tuweni-devp2p
* Refactor EthereumNodeRecord for DNSDaemon
* Update EthereumNodeRecord to use Besu RLP
* additional unit tests
* Convert ENR to Java record
* regenerate equals and hashcode for enr record
---------

Signed-off-by: Usman Saleem <[email protected]>

Author: usmansaleem

crypto/algorithms/src/main/java/org/hyperledger/besu/crypto/AbstractSECP256.java

@@ -233,6 +233,11 @@ public String getProvider() {
     return PROVIDER;
   }
 
+  @Override
+  public ECDomainParameters getCurve() {
+    return curve;
+  }
+
   /**
    * Gets K calculator.
    *

crypto/algorithms/src/main/java/org/hyperledger/besu/crypto/SignatureAlgorithm.java

@@ -20,6 +20,7 @@
 
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.bytes.Bytes32;
+import org.bouncycastle.crypto.params.ECDomainParameters;
 import org.bouncycastle.math.ec.ECPoint;
 
 /** The interface Signature algorithm. */
@@ -124,6 +125,13 @@ SECPSignature normaliseSignature(
    */
   String getCurveName();
 
+  /**
+   * Bouncy castle ECDomainParameters representing the curve.
+   *
+   * @return instance of ECDomainParameters
+   */
+  ECDomainParameters getCurve();
+
   /**
    * Create secp private key.
    *

ethereum/p2p/build.gradle

@@ -46,9 +46,6 @@ dependencies {
 
   implementation 'io.tmio:tuweni-bytes'
   implementation 'io.tmio:tuweni-crypto'
-  implementation('io.tmio:tuweni-devp2p') {
-    exclude group:'ch.qos.logback', module:'logback-classic'
-  }
   implementation 'io.tmio:tuweni-io'
   implementation 'io.tmio:tuweni-rlp'
   implementation 'io.tmio:tuweni-units'

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/discovery/dns/DNSDaemon.java

@@ -18,7 +18,6 @@
 import java.util.Optional;
 
 import io.vertx.core.AbstractVerticle;
-import org.apache.tuweni.devp2p.EthereumNodeRecord;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/discovery/dns/DNSDaemonListener.java

@@ -16,8 +16,6 @@
 
 import java.util.List;
 
-import org.apache.tuweni.devp2p.EthereumNodeRecord;
-
 // Adapted from https://github.com/tmio/tuweni and licensed under Apache 2.0
 /** Callback listening to updates of the DNS records. */
 @FunctionalInterface

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/discovery/dns/DNSEntry.java

@@ -25,7 +25,6 @@
 
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.crypto.SECP256K1;
-import org.apache.tuweni.devp2p.EthereumNodeRecord;
 import org.apache.tuweni.io.Base32;
 import org.apache.tuweni.io.Base64URLSafe;
 import org.bouncycastle.math.ec.ECPoint;

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/discovery/dns/DNSResolver.java

@@ -33,7 +33,6 @@
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.bytes.Bytes32;
 import org.apache.tuweni.crypto.SECP256K1;
-import org.apache.tuweni.devp2p.EthereumNodeRecord;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/discovery/dns/DNSVisitor.java

@@ -14,8 +14,6 @@
  */
 package org.hyperledger.besu.ethereum.p2p.discovery.dns;
 
-import org.apache.tuweni.devp2p.EthereumNodeRecord;
-
 // Adapted from https://github.com/tmio/tuweni and licensed under Apache 2.0
 /**
  * Reads ENR (Ethereum Node Records) entries passed in from DNS. The visitor may decide to stop the

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/discovery/dns/EthereumNodeRecord.java

@@ -0,0 +1,154 @@
+/*
+ * Copyright contributors to Hyperledger Besu.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Adapted from https://github.com/tmio/tuweni and licensed under Apache 2.0
+package org.hyperledger.besu.ethereum.p2p.discovery.dns;
+
+import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
+import org.hyperledger.besu.ethereum.rlp.BytesValueRLPInput;
+
+import java.net.InetAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+import org.apache.tuweni.bytes.Bytes;
+
+/**
+ * A modified implementation of Ethereum Node Record (ENR) that is used by DNSResolver. See <a
+ * href="https://eips.ethereum.org/EIPS/eip-778">EIP-778</a>
+ */
+public record EthereumNodeRecord(
+    Bytes rlp, Bytes publicKey, InetAddress ip, Optional<Integer> tcp, Optional<Integer> udp) {
+
+  /**
+   * Creates an ENR from its serialized form as a RLP list
+   *
+   * @param rlp the serialized form of the ENR
+   * @return the ENR
+   * @throws IllegalArgumentException if the rlp bytes length is longer than 300 bytes
+   */
+  public static EthereumNodeRecord fromRLP(final Bytes rlp) {
+    if (rlp.size() > 300) {
+      throw new IllegalArgumentException("Record too long");
+    }
+    var data = new HashMap<String, Bytes>();
+
+    // rlp: sig, sequence, k1,v1, k2,v2, k3, [v3, vn]...
+    var input = new BytesValueRLPInput(rlp, false);
+    input.enterList();
+
+    input.skipNext(); // skip signature
+    input.skipNext(); // skip sequence
+
+    // go through rest of the list
+    while (!input.isEndOfCurrentList()) {
+      var key = new String(input.readBytes().toArrayUnsafe(), StandardCharsets.UTF_8);
+      if (input.nextIsList()) {
+        // skip list as we currently don't need any of these complex structures
+        input.skipNext();
+      } else {
+        data.put(key, input.readBytes());
+      }
+    }
+
+    input.leaveList();
+
+    var publicKey = initPublicKeyBytes(data);
+
+    return new EthereumNodeRecord(rlp, publicKey, initIPAddr(data), initTCP(data), initUDP(data));
+  }
+
+  /**
+   * Returns the public key of the ENR
+   *
+   * @return the public key of the ENR
+   */
+  static Bytes initPublicKeyBytes(final Map<String, Bytes> data) {
+    var keyBytes = data.get("secp256k1");
+    if (keyBytes == null) {
+      throw new IllegalArgumentException("Missing secp256k1 entry in ENR");
+    }
+    // convert 33 bytes compressed public key to uncompressed using Bouncy Castle
+    var curve = SignatureAlgorithmFactory.getInstance().getCurve();
+    var ecPoint = curve.getCurve().decodePoint(keyBytes.toArrayUnsafe());
+    // uncompressed public key is 65 bytes, first byte is 0x04.
+    var encodedPubKey = ecPoint.getEncoded(false);
+    return Bytes.of(Arrays.copyOfRange(encodedPubKey, 1, encodedPubKey.length));
+  }
+
+  /**
+   * Returns the InetAddress of the ENR
+   *
+   * @return The IP address of the ENR
+   */
+  static InetAddress initIPAddr(final Map<String, Bytes> data) {
+    var ipBytes = data.get("ip");
+    if (ipBytes != null) {
+      try {
+        return InetAddress.getByAddress(ipBytes.toArrayUnsafe());
+      } catch (final Exception e) {
+        throw new RuntimeException(e);
+      }
+    }
+    return InetAddress.getLoopbackAddress();
+  }
+
+  /**
+   * The TCP port of the ENR
+   *
+   * @return the TCP port associated with this ENR
+   */
+  static Optional<Integer> initTCP(final Map<String, Bytes> data) {
+    var tcpBytes = data.get("tcp");
+    return tcpBytes != null ? Optional.of(tcpBytes.toInt()) : Optional.empty();
+  }
+
+  /**
+   * The UDP port of the ENR. If the UDP port is not present, the TCP port is used.
+   *
+   * @return the UDP port associated with this ENR
+   */
+  static Optional<Integer> initUDP(final Map<String, Bytes> data) {
+    var udpBytes = data.get("udp");
+    return udpBytes != null ? Optional.of(udpBytes.toInt()) : initTCP(data);
+  }
+
+  /**
+   * @return the ENR as a URI
+   */
+  @Override
+  public String toString() {
+    return "enr:" + ip() + ":" + tcp() + "?udp=" + udp();
+  }
+
+  /** Override equals method to compare the RLP bytes */
+  @Override
+  public boolean equals(final Object o) {
+    if (!(o instanceof EthereumNodeRecord that)) {
+      return false;
+    }
+    return Objects.equals(rlp, that.rlp);
+  }
+
+  /** Override hashCode method to use hashCode of the RLP bytes */
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(rlp);
+  }
+}

ethereum/p2p/src/main/java/org/hyperledger/besu/ethereum/p2p/network/DefaultP2PNetwork.java

@@ -29,6 +29,7 @@
 import org.hyperledger.besu.ethereum.p2p.discovery.VertxPeerDiscoveryAgent;
 import org.hyperledger.besu.ethereum.p2p.discovery.dns.DNSDaemon;
 import org.hyperledger.besu.ethereum.p2p.discovery.dns.DNSDaemonListener;
+import org.hyperledger.besu.ethereum.p2p.discovery.dns.EthereumNodeRecord;
 import org.hyperledger.besu.ethereum.p2p.discovery.internal.PeerTable;
 import org.hyperledger.besu.ethereum.p2p.peers.DefaultPeerPrivileges;
 import org.hyperledger.besu.ethereum.p2p.peers.EnodeURLImpl;
@@ -82,7 +83,6 @@
 import io.vertx.core.ThreadingModel;
 import io.vertx.core.Vertx;
 import org.apache.tuweni.bytes.Bytes;
-import org.apache.tuweni.devp2p.EthereumNodeRecord;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -366,9 +366,9 @@ DNSDaemonListener createDaemonListener() {
         final EnodeURL enodeURL =
             EnodeURLImpl.builder()
                 .ipAddress(enr.ip())
-                .nodeId(enr.publicKey().bytes())
-                .discoveryPort(Optional.ofNullable(enr.udp()))
-                .listeningPort(Optional.ofNullable(enr.tcp()))
+                .nodeId(enr.publicKey())
+                .discoveryPort(enr.udp())
+                .listeningPort(enr.tcp())
                 .build();
         final DiscoveryPeer peer = DiscoveryPeer.fromEnode(enodeURL);
         peers.add(peer);