reth_discv5/
enr.rs

1//! Interface between node identification on protocol version 5 and 4. Specifically, between types
2//! [`enr::NodeId`] and [`PeerId`].
3
4use enr::{CombinedPublicKey, Enr, EnrPublicKey, NodeId};
5use reth_network_peers::{id2pk, pk2id, PeerId};
6use secp256k1::{PublicKey, SecretKey};
7
8/// Extracts a [`CombinedPublicKey::Secp256k1`] from a [`discv5::Enr`] and converts it to a
9/// [`PeerId`]. Note: conversion from discv5 ID to discv4 ID is not possible.
10pub fn enr_to_discv4_id(enr: &discv5::Enr) -> Option<PeerId> {
11    let pk = enr.public_key();
12    if !matches!(pk, CombinedPublicKey::Secp256k1(_)) {
13        return None
14    }
15
16    let pk = PublicKey::from_slice(&pk.encode()).unwrap();
17
18    Some(pk2id(&pk))
19}
20
21/// Converts a [`PeerId`] to a [`enr::NodeId`].
22pub fn discv4_id_to_discv5_id(peer_id: PeerId) -> Result<NodeId, secp256k1::Error> {
23    Ok(id2pk(peer_id)?.into())
24}
25
26/// Converts a [`PeerId`] to a [`libp2p_identity::PeerId`].
27pub fn discv4_id_to_multiaddr_id(
28    peer_id: PeerId,
29) -> Result<libp2p_identity::PeerId, secp256k1::Error> {
30    let pk = id2pk(peer_id)?.encode();
31    let pk: libp2p_identity::PublicKey =
32        libp2p_identity::secp256k1::PublicKey::try_from_bytes(&pk).unwrap().into();
33
34    Ok(pk.to_peer_id())
35}
36
37/// Wrapper around [`discv5::Enr`] ([`Enr<CombinedKey>`]).
38#[derive(Debug, Clone)]
39pub struct EnrCombinedKeyWrapper(pub discv5::Enr);
40
41impl TryFrom<Enr<SecretKey>> for EnrCombinedKeyWrapper {
42    type Error = alloy_rlp::Error;
43
44    fn try_from(value: Enr<SecretKey>) -> Result<Self, Self::Error> {
45        // The k256 backend of `discv5::Enr` rejects some public key encodings that libsecp256k1
46        // accepts.
47        let encoded_enr = alloy_rlp::encode(&value);
48        alloy_rlp::Decodable::decode(&mut &encoded_enr[..]).map(Self)
49    }
50}
51
52impl From<EnrCombinedKeyWrapper> for Enr<SecretKey> {
53    fn from(val: EnrCombinedKeyWrapper) -> Self {
54        let encoded_enr = alloy_rlp::encode(&val.0);
55        alloy_rlp::Decodable::decode(&mut &encoded_enr[..]).unwrap()
56    }
57}
58
59#[cfg(test)]
60mod tests {
61    use super::*;
62    use alloy_primitives::keccak256;
63    use alloy_rlp::{Encodable, Header};
64    use enr::{CombinedKey, EnrKey};
65    use reth_chainspec::{EthereumHardfork, MAINNET};
66    use reth_network_peers::NodeRecord;
67
68    #[test]
69    fn discv5_discv4_id_conversion() {
70        let discv5_pk = CombinedKey::generate_secp256k1().public();
71        let discv5_peer_id = NodeId::from(discv5_pk.clone());
72
73        // convert to discv4 id
74        let pk = secp256k1::PublicKey::from_slice(&discv5_pk.encode()).unwrap();
75        let discv4_peer_id = pk2id(&pk);
76        // convert back to discv5 id
77        let discv5_peer_id_from_discv4_peer_id = discv4_id_to_discv5_id(discv4_peer_id).unwrap();
78
79        assert_eq!(discv5_peer_id, discv5_peer_id_from_discv4_peer_id)
80    }
81
82    #[test]
83    fn conversion_to_node_record_from_enr() {
84        const IP: &str = "::";
85        const TCP_PORT: u16 = 30303;
86        const UDP_PORT: u16 = 9000;
87
88        let key = CombinedKey::generate_secp256k1();
89
90        let mut buf = Vec::new();
91        let fork_id = MAINNET.hardfork_fork_id(EthereumHardfork::Frontier);
92        fork_id.unwrap().encode(&mut buf);
93
94        let enr = Enr::builder()
95            .ip6(IP.parse().unwrap())
96            .udp6(UDP_PORT)
97            .tcp6(TCP_PORT)
98            .build(&key)
99            .unwrap();
100
101        let enr = EnrCombinedKeyWrapper(enr).into();
102        let node_record = NodeRecord::try_from(&enr).unwrap();
103
104        assert_eq!(
105            NodeRecord {
106                address: IP.parse().unwrap(),
107                tcp_port: TCP_PORT,
108                udp_port: UDP_PORT,
109                id: pk2id(&enr.public_key())
110            },
111            node_record
112        )
113    }
114
115    #[test]
116    fn enr_conversion_rejects_hybrid_encoded_key() {
117        let sk = SecretKey::from_secret_bytes([1; 32]).unwrap();
118        // Hybrid encoding: an uncompressed point with the y parity in the prefix byte.
119        let mut pk = sk.public_key().serialize_uncompressed();
120        pk[0] = 0x06 | (pk[64] & 1);
121
122        let rlp_list = |payload: &[u8]| {
123            let mut out = Vec::new();
124            Header { list: true, payload_length: payload.len() }.encode(&mut out);
125            out.extend_from_slice(payload);
126            out
127        };
128        let mut content = Vec::new();
129        1u64.encode(&mut content);
130        for item in [&b"id"[..], b"v4", b"secp256k1", &pk] {
131            item.encode(&mut content);
132        }
133        let msg = secp256k1::Message::from_digest(keccak256(rlp_list(&content)).0);
134        let mut payload = Vec::new();
135        secp256k1::ecdsa::sign(msg, &sk).serialize_compact().as_slice().encode(&mut payload);
136        payload.extend_from_slice(&content);
137
138        let enr = alloy_rlp::decode_exact::<Enr<SecretKey>>(rlp_list(&payload)).unwrap();
139        assert_eq!(
140            EnrCombinedKeyWrapper::try_from(enr).unwrap_err(),
141            alloy_rlp::Error::Custom("Unknown signature")
142        );
143    }
144}
reth_discv5/enr.rs

reth_discv5/
enr.rs
