这是我写的从头完整实现以太坊协议系列的第三部分（第一部分，第二部分）。我们目前已经实现了以太坊发现协议——用于查找其他可以与之进行区块链同步的节点的算法。我们已经能够ping通引导节点——写在源代码里面的，用于查找其他节点的起始端点。节点响应了一条消息，但是我们还未对它进行解码。今天我们就要来解码这个引导节点响应的消息。

到https://github.com/HuangFJ/pyeth下载本项目代码：
git clone https://github.com/HuangFJ/pyeth

数据解包

这一节，我们将写一些函数用来将RLP编码的PingNode和Pong消息解包为Python对象。这些方法将在哈希和签名验证后，读取消息数据。我们已经定义了PingNode类，现在要实现Pong类。

在RLPx规范中，Pong被定义成：

Pong packet-type: 0x02struct Pong{
    Endpoint to;
    h256 echo;    uint32_t timestamp;
};

让我们在pyeth/discovery.py里写一个此结构相对应的类：

class Pong(object):
    packet_type = '\x02'

    def __init__(self, to, echo, timestamp):
        self.to = to
        self.echo = echo
        self.timestamp = timestamp    def __str__(self):
        return "(Pong " + str(self.to) + " <echo hash=""> " + str(self.timestamp) + ")"

    def pack(self):
        return [
            self.to.pack(),
            self.echo,
            struct.pack(">I", self.timestamp)]    @classmethod
    def unpack(cls, packed):
        to = EndPoint.unpack(packed[0])
        echo = packed[1]
        timestamp = struct.unpack(">I", packed[2])[0]        return cls(to, echo, timestamp)

这个类把包结构编码为Python对象，packet_type作为类字段，并将to，echo和timestamp传递给构造函数。我添加了一个__str__方法用于打印对象，这里要用到to，它是一个EndPoint对象，它也要一个__str__方法。我们定义为：

class EndPoint(object):
    ...    
    def __str__(self):
        return "(EP " + self.address.exploded + " " + str(self.udpPort) + " " +  str(self.tcpPort)  + ")"
    ...

回到Pong类。就如第一部分以及RLP规范所述，pack方法把对象转为item格式供rlp.encode消费，item是二进制字符串或者多个item的列表。我们需要编码to，echo和timestamp。对于to，我们可以用to.pack()，因为item的定义是递归的。接着，echo已经是字符串，因此它不需要再转化。最后，我用带有>I参数的struct.pack将timestamp编码为大端无符号32位整型。

unpack方法是pack的逆过程。对于to，我们用下面定义的EndPoint unpack来解码:

class EndPoint(object):
    ...    @classmethod
    def unpack(cls, packed):
        udpPort = struct.unpack(">H", packed[1])[0]
        tcpPort = struct.unpack(">H", packed[2])[0]        return cls(packed[0], udpPort, tcpPort)

tcpPort和udpPort用struct.unpack取回，IP地址以字符串格式传递，由ip_address的构造函数处理。

因为echo被定义为h256，256字节的哈希，它可以解包成自己本身。timestamp被用struct.unpack解包成大端32位整型。

我们还需要定义PingNode的__str__和unpack方法，如下：

class PingNode(object):
    packet_type = '\x01';
    version = '\x03';    def __init__(self, endpoint_from, endpoint_to, timestamp):
        self.endpoint_from = endpoint_from
        self.endpoint_to = endpoint_to
        self.timestamp = timestamp    def __str__(self):
        return "(Ping " + str(ord(self.version)) + " " + str(self.endpoint_from) + " " + str(self.endpoint_to) + " " +  str(self.timestamp) + ")"


    def pack(self):
        return [self.version,
                self.endpoint_from.pack(),
                self.endpoint_to.pack(),
                struct.pack(">I", self.timestamp)]    @classmethod
    def unpack(cls, packed):
        assert(packed[0] == cls.version)
        endpoint_from = EndPoint.unpack(packed[1])
        endpoint_to = EndPoint.unpack(packed[2])        return cls(endpoint_from, endpoint_to)

对PingNode构造函数的修改会牵涉到PingServer的ping方法，此处也应做相应修改：

def ping(self, endpoint):
    ping = PingNode(self.endpoint, endpoint, time.time() + 60)
    message = self.wrap_packet(ping)    print "sending " + str(ping)
    self.sock.sendto(message, (endpoint.address.exploded, endpoint.udpPort))

解码响应消息

回顾一下我们第一部分讨论的在RLPx规范中的消息排列（||是连接符号）：
hash || signature || packet-type || packet-data

在这一节，我们检查消息的哈希和签名，如果都有效，才根据packet-type解码不同类型的消息。在pyeth/discovery.py中，我们的包监听函数udp_listen被定义在PingServer里面：

def udp_listen(self):
    def receive_ping():
        print "listening..."
        data, addr = self.sock.recvfrom(1024)        print "received message[", addr, "]"

    return threading.Thread(target = receive_ping)

我将把receive_ping拆分为更通用的函数，名称叫做receive，它将用于包解码：

def udp_listen(self):
    return threading.Thread(target = self.receive)def receive(self):
    print "listening..."
    data, addr = self.sock.recvfrom(1024)    print "received message[", addr, "]"

    ## decode packet below

现在我们要填充## decode packet below这一行以下的代码，从解码哈希开始。我们把下面的代码添加到receive函数：

## verify hashmsg_hash = data[:32]if msg_hash != keccak256(data[32:]):    print " First 32 bytes are not keccak256 hash of the rest."
    returnelse:    print " Verified message hash."

第二步就是验证secp256k1签名。首先我们用secp256k1库把签名反系列化成对象，然后我们从签名里面取回公钥，然后我们用公钥来验证签名。为了反系列化，我们使用服务器私钥priv_key的ecdsa_recoverable_deserialize方法。我们之前用sig_serialized[0] + chr(sig_serialized[1])编码签名，第一项是64字节，第二项是1字节。因此我们需要抓取哈希之后的65字节，接着把签名分成64字节和1字节的参数并对最后一个字节使用ord函数——chr的逆过程。

## verify signaturesignature = data[32:97]
signed_data = data[97:]
deserialized_sig = self.priv_key.ecdsa_recoverable_deserialize(signature[:64],
                                                               ord(signature[64]))

为了取回公钥，我们使用ecdsa_recover。还记得我们之前用raw = True告诉算法我们使用自己的keccak256哈希算法替代函数默认的哈希算法吗。

remote_pubkey = self.priv_key.ecdsa_recover(keccak256(signed_data),
                                            deserialized_sig,
                                            raw = True)

现在我们创建PublicKey对象来存储公钥。我们要在文件头部引入这个类：
from secp256k1 import PrivateKey, PublicKey
回到receive，我们继续编写：

pub = PublicKey()
pub.public_key = remote_pubkey

现在我们可以使用ecdsa_verify验证signed_data是否被deserialized_sig签名过：

verified = pub.ecdsa_verify(keccak256(signed_data),
                            pub.ecdsa_recoverable_convert(deserialized_sig),
                            raw = True)if not verified:    print " Signature invalid"
    returnelse:    print " Verified signature."

最后一步就是解包消息。具体用什么函数由packet_type字节确定。

response_types = {
    PingNode.packet_type : self.receive_ping,
    Pong.packet_type : self.receive_pong
}try:
    packet_type = data[97]
    dispatch = response_types[packet_type]except KeyError:    print " Unknown message type: " + data[97]    returnpayload = data[98:]
dispatch(payload)

我们将receive_ping和receive_pong保持简单，就如PingServer的其他函数。

def receive_pong(self, payload):
    print " received Pong"
    print "", Pong.unpack(rlp.decode(payload))def receive_ping(self, payload):
    print " received Ping"
    print "", PingNode.unpack(rlp.decode(payload))

让我们运行python send_ping.py检查一下看看程序如何运行。你应该会看到：

sending (Ping 3 (EP 52.4.20.183 30303 30303) (EP 13.93.211.84 30303 30303) 1501093574.21)
listening...
received message[ ('13.93.211.84', 30303) ]:
 Verified message hash.
 Verified signature.
 received Pong
 (Pong (EP 52.4.20.183 30303 30303) <echo hash=""> 1501093534)

我们已经成功验证和解码了Pong消息。下次，我们将实现FindNeighbors消息和Neighbors响应消息。

作者：JonHuang
链接：https://www.jianshu.com/p/d0afed2d188f