以太坊网络架构解析

做者：0x7F@知道创宇404区块链安全研究团队

0x00 前言

区块链的火热程度一直以直线上升，其中以区块链 2.0 —— 以太坊为表明，不断的为传统行业带来革新，同时也推进区块链技术发展。

区块链是一种分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式，这是一个典型的去中心化应用，创建在 p2p 网络之上；本文以学习和分析以太坊运做原理为目的，将以太坊网络架构做为一个切入点，逐步深刻分析，最终对以太坊网络架构有个大体的了解。

经过学习以太坊网络架构，能够更容易的对网络部分的源码进行审计，便于后续的协议分析，来发现未知的安全隐患；除此以外，目前基于 p2p 网络的成熟的应用很是少，借助分析以太坊网络架构的机会，能够学习一套成熟的 p2p 网络运行架构。

本文侧重于数据链路的创建和交互，不涉及网络模块中的节点发现、区块同步、广播等功能模块。

0x01 目录

1. Geth 启动
2. 网络架构
3. 共享密钥
4. RLPXFrameRW 帧
5. RLP 编码
6. LES 协议
7. 总结

其中第 三、四、5 三个小节是第 2 节「网络架构」的子内容，做为详细的补充。

0x02 Geth 启动

在介绍以太坊网络架构以前，首先简单分析下 Geth 的总体启动流程，便于后续的理解和分析。

以太坊源码目录

1.  
   tree -d -L 1
2.  
   .
3.  
   ├── accounts 帐号相关
4.  
   ├── bmt 实现二叉merkle树
5.  
   ├── build 编译生成的程序
6.  
   ├── cmd geth程序主体
7.  
   ├── common 工具函数库
8.  
   ├── consensus 共识算法
9.  
   ├── console 交互式命令
10.  
    ├── containers docker 支持相关
11.  
    ├── contracts 合约相关
12.  
    ├── core 以太坊核心部分
13.  
    ├── crypto 加密函数库
14.  
    ├── dashboard 统计
15.  
    ├── eth 以太坊协议
16.  
    ├── ethclient 以太坊RPC客户端
17.  
    ├── ethdb 底层存储
18.  
    ├── ethstats 统计报告
19.  
    ├── event 事件处理
20.  
    ├── internal RPC调用
21.  
    ├── les 轻量级子协议
22.  
    ├── light 轻客户端部分功能
23.  
    ├── log 日志模块
24.  
    ├── metrics 服务监控相关
25.  
    ├── miner 挖矿相关
26.  
    ├── mobile geth的移动端API
27.  
    ├── node 接口节点
28.  
    ├── p2p p2p网络协议
29.  
    ├── params 一些预设参数值
30.  
    ├── rlp RLP系列化格式
31.  
    ├── rpc RPC接口
32.  
    ├── signer 签名相关
33.  
    ├── swarm 分布式存储
34.  
    ├── tests 以太坊JSON测试
35.  
    ├── trie Merkle Patricia实现
36.  
    ├── vendor 一些扩展库
37.  
    └── whisper 分布式消息
38.  
     
39.  
    35 directories

初始化工做

Geth 的 main() 函数很是的简洁，经过 app.Run() 来启动程序：

1.  
   [./cmd/geth/main. go]
2.  
   func main() {
3.  
   if err := app.Run(os.Args); err != nil {
4.  
   fmt.Fprintln(os.Stderr, err)
5.  
   os.Exit( 1)
6.  
   }
7.  
   }

其简洁是得力于 Geth 使用了 gopkg.in/urfave/cli.v1 扩展包，该扩展包用于管理程序的启动，以及命令行解析，其中 app 是该扩展包的一个实例。

在 Go 语言中，在有 init() 函数的状况下，会默认先调用 init() 函数，而后再调用 main() 函数；Geth 几乎在 ./cmd/geth/main.go#init() 中完成了全部的初始化操做：设置程序的子命令集，设置程序入口函数等，下面看下 init() 函数片断：

1.  
   [./cmd/geth/main. go]
2.  
   func init() {
3.  
   // Initialize the CLI app and start Geth
4.  
   app.Action = geth
5.  
   app.HideVersion = true // we have a command to print the version
6.  
   app.Copyright = "Copyright 2013-2018 The go-ethereum Authors"
7.  
   app.Commands = []cli.Command{
8.  
   // See chaincmd.go:
9.  
   initCommand,
10.  
    importCommand,
11.  
    exportCommand,
12.  
    importPreimagesCommand,
13.  
    ...
14.  
    }
15.  
    ...
16.  
    }

在以上代码中，预设了 app实例的值，其中 app.Action = geth做为 app.Run()调用的默认函数，而 app.Commands保存了子命令实例，经过匹配命令行参数能够调用不一样的函数(而不调用 app.Action)，使用 Geth 不一样的功能，如：开启带控制台的 Geth、使用 Geth 创造创世块等。

节点启动流程

不管是经过 geth() 函数仍是其余的命令行参数启动节点，节点的启动流程大体都是相同的，这里以 geth() 为例：

1.  
   [./cmd/geth/main.go]
2.  
   func geth(ctx *cli.Context) error {
3.  
   node := makeFullNode(ctx)
4.  
   startNode(ctx, node)
5.  
   node. Wait()
6.  
   return nil
7.  
   }

其中makeFullNode()函数将返回一个节点实例，而后经过startNode()启动。在 Geth 中，每个功能模块都被视为一个服务，每个服务的正常运行驱动着 Geth 的各项功能；makeFullNode()经过解析命令行参数，注册指定的服务。如下是 makeFullNode()代码片断：

1.  
   [./cmd/geth/config. go]
2.  
   func makeFullNode(ctx *cli.Context) *node.Node {
3.  
   stack, cfg := makeConfigNode(ctx)
4.  
    
5.  
   utils.RegisterEthService(stack, &cfg.Eth)
6.  
    
7.  
   if ctx.GlobalBool(utils.DashboardEnabledFlag.Name) {
8.  
   utils.RegisterDashboardService(stack, &cfg.Dashboard, gitCommit)
9.  
   }
10.  
     
11.  
    ...
12.  
     
13.  
    // Add the Ethereum Stats daemon if requested.
14.  
    if cfg.Ethstats.URL != "" {
15.  
    utils.RegisterEthStatsService(stack, cfg.Ethstats.URL)
16.  
    }
17.  
    return stack
18.  
    }

而后经过 startNode() 启动各项服务并运行节点。如下是 Geth 启动流程图：

每一个服务正常运行，相互协做，构成了 Geth：

0x03 网络架构

经过 main() 函数的调用，最终启动了 p2p 网络，这一小节对网络架构作详细的分析。

三层架构
以太坊是去中心化的数字货币系统，自然适用 p2p 通讯架构，而且在其上还支持了多种协议。在以太坊中，p2p 做为通讯链路，用于负载上层协议的传输，能够将其分为三层结构：

1. 最上层是以太坊中各个协议的具体实现，如 eth 协议、les 协议。
2. 第二层是以太坊中的 p2p 通讯链路层，主要负责启动监听、处理新加入链接或维护链接，为上层协议提供了信道。
3. 最下面的一层，是由 Go 语言所提供的网络 IO 层，也就是对 TCP/IP 中的网络层及如下的封装。

p2p 通讯链路层
从最下层开始逐步分析，第三层是由 Go 语言所封装的网络 IO 层，这里就跳过了，直接分析 p2p 通讯链路层。p2p 通讯链路层主要作了三项工做：

1. 由上层协议的数据交付给 p2p 层后，首先经过 RLP 编码。
2. RLP 编码后的数据将由共享密钥进行加密，保证通讯过程当中数据的安全。
3. 最后，将数据流转换为 RLPXFrameRW 帧，便于数据的加密传输和解析。
   (以上三点由下文作分析)

p2p 源码分析
p2p 一样做为 Geth 中的一项服务，经过「0x03 Geth 启动」中 startNode() 启动，p2p 经过其 Start() 函数启动。如下是 Start() 函数代码片断：

1.  
   [./p2p/server. go]
2.  
   func (srv *Server) Start() (err error) {
3.  
   ...
4.  
   if !srv.NoDiscovery {
5.  
   ...
6.  
   }
7.  
   if srv.DiscoveryV5 {
8.  
   ...
9.  
   }
10.  
    ...
11.  
    // listen/dial
12.  
    if srv.ListenAddr != "" {
13.  
    if err := srv.startListening(); err != nil {
14.  
    return err
15.  
    }
16.  
    }
17.  
    ...
18.  
    go srv.run(dialer)
19.  
    ...
20.  
    }

上述代码中，设置了 p2p 服务的基础参数，并根据用户参数开启节点发现(节点发现不在本文的讨论范围内)，随后开启 p2p 服务监听，最后开启单独的协程用于处理报文。如下分为服务监听和报文处理两个模块来分析。

服务监听

经过 startListening() 的调用进入到服务监听的流程中，随后在该函数中调用 listenLoop 用一个无限循环处理接受链接，随后经过 SetupConn() 函数为正常的链接创建 p2p 通讯链路。在 SetupConn() 中调用 setupConn() 来作具体工做，如下是 setupConn() 的代码片断：

1.  
   [./p2p/server.go]
2.  
   func (srv *Server) setupConn(c *conn, flags connFlag, dialDest *discover.Node) error {
3.  
   ...
4.  
   if c.id, err = c.doEncHandshake(srv.PrivateKey, dialDest); err != nil {
5.  
   srv.log. Trace("Failed RLPx handshake", "addr", c.fd.RemoteAddr(), "conn", c.flags, "err", err)
6.  
   return err
7.  
   }
8.  
   ...
9.  
   phs, err := c.doProtoHandshake(srv.ourHandshake)
10.  
    ...
11.  
    }

setupConn() 函数中主要由 doEncHandshake() 函数与客户端交换密钥，并生成临时共享密钥，用于本次通讯加密，并建立一个帧处理器 RLPXFrameRW；再调用 doProtoHandshake() 函数为本次通讯协商遵循的规则和事务，包含版本号、名称、容量、端口号等信息。在成功创建通讯链路，完成协议握手后，处理流程转移到报文处理模块。

下面是服务监听函数调用流程：

报文处理

p2p.Start() 经过调用 run() 函数处理报文，run() 函数用无限循环等待事务，好比上文中，新链接完成握手包后，将由该函数来负责。run() 函数中支持多个命令的处理，包含的命令有服务退出清理、发送握手包、添加新节点、删除节点等。如下是 run() 函数结构：

1.  
   [./p2p/server. go]
2.  
   func (srv *Server) run(dialstate dialer) {
3.  
   ...
4.  
   for {
5.  
   select {
6.  
   case <-srv.quit: ...
7.  
   case n := <-srv.addstatic: ...
8.  
   case n := <-srv.removestatic: ...
9.  
   case op := <-srv.peerOp: ...
10.  
    case t := <-taskdone: ...
11.  
    case c := <-srv.posthandshake: ...
12.  
    case c := <-srv.addpeer: ...
13.  
    case pd := <-srv.delpeer: ...
14.  
    }
15.  
    }
16.  
    }

为了理清整个网络架构，本文直接讨论 addpeer 分支：当一个新节点添加服务器节点时，将进入到该分支下，根据以前的握手信息，为上层协议生成实例，而后调用 runPeer()，最终经过 p.run() 进入报文的处理流程中。

继续分析 p.run() 函数，其开启了读取数据和 ping 两个协程，用于处理接收报文和维持链接，随后经过调用 startProtocols() 函数，调用指定协议的 Run() 函数，进入具体协议的处理流程。

下面是报文处理函数调用流程

p2p 通讯链路交互流程

这里总体看下 p2p 通讯链路的处理流程，以及对数据包的封装。

0x04 共享密钥

在 p2p 通讯链路的创建过程当中，第一步就是协商共享密钥，该小节说明下密钥的生成过程。

迪菲-赫尔曼密钥交换
p2p 网络中使用到的是「迪菲-赫尔曼密钥交换」技术[1]。迪菲-赫尔曼密钥交换（英语：Diffie–Hellman key exchange，缩写为D-H） 是一种安全协议。它可让双方在彻底没有对方任何预先信息的条件下经过不安全信道建立起一个密钥。

简单来讲，连接的两方生成随机的私钥，经过随机的私钥获得公钥。而后双方交换各自的公钥，这样双方均可以经过本身随机的私钥和对方的公钥来生成一个一样的共享密钥(shared-secret)。后续的通信使用这个共享密钥做为对称加密算法的密钥。其中对于 A、B公私钥对知足这样的数学等式：ECDH(A私钥, B公钥) == ECDH(B私钥, A公钥)。

共享密钥生成
在 p2p 网络中由 doEncHandshake() 方法完成密钥的交换和共享密钥的生成工做。下面是该函数的代码片断：

1.  
   [./p2p/rlpx. go]
2.  
   func (t *rlpx) doEncHandshake(prv *ecdsa.PrivateKey, dial *discover.Node) (discover.NodeID, error) {
3.  
   ...
4.  
   if dial == nil {
5.  
   sec, err = receiverEncHandshake(t.fd, prv, nil)
6.  
   } else {
7.  
   sec, err = initiatorEncHandshake(t.fd, prv, dial.ID, nil)
8.  
   }
9.  
   ...
10.  
    t.rw = newRLPXFrameRW(t.fd, sec)
11.  
    ..
12.  
    }

若是做为服务端监听链接，收到新链接后调用 receiverEncHandshake() 函数，若做为客户端向服务端发起请求，则调用 initiatorEncHandshake()函数；两个函数区别不大，都将交换密钥，并生成共享密钥，initiatorEncHandshake() 仅仅是做为发起数据的一端；最终执行完后，调用 newRLPXFrameRW() 建立帧处理器。

从服务端的角度来看，将调用 receiverEncHandshake() 函数来建立共享密钥，如下是该函数的代码片断：

1.  
   [./p2p/rlpx. go]
2.  
   func receiverEncHandshake(conn io.ReadWriter, prv *ecdsa.PrivateKey, token []byte) (s secrets, err error) {
3.  
   authPacket, err := readHandshakeMsg(authMsg, encAuthMsgLen, prv, conn)
4.  
   ...
5.  
   authRespMsg, err := h.makeAuthResp()
6.  
   ...
7.  
   if _, err = conn.Write(authRespPacket); err != nil {
8.  
   return s, err
9.  
   }
10.  
    return h.secrets(authPacket, authRespPacket)
11.  
    }

共享密钥生成的过程：

1. 在完成 TCP 链接后，客户端使用服务端的公钥(node_id)加密，发送本身的公钥和包含临时公钥的签名，还有一个随机值 nonce。
2. 服务端收到数据，得到客户端的公钥，使用椭圆曲线算法从签名中得到客户端的临时公钥；服务端将本身的临时公钥和随机值 nonce 用客户端的公钥加密发送。
3. 经过上述两步的密钥交换后，对于客户端目前有本身的临时公私钥对和服务端的临时公钥，使用椭圆曲线算法从本身的临时私钥和服务端的临时公钥计算得出共享密钥；同理，服务端按照相同的方式也能够计算出共享密钥。

如下是共享密钥生成图示：

得出共享密钥后，客户端和服务端就可使用共享密钥作对称加密，完成对通讯的加密。

0x05 RLPXFrameRW 帧

在共享密钥生成完毕后，初始化了 RLPXFrameRW 帧处理器；其 RLPXFrameRW 帧的目的是为了在单个链接上支持多路复用协议。其次，因为帧分组的消息为加密数据流产生了自然的分界点，更便于数据的解析，除此以外，还能够对发送的数据进行验证。

RLPXFrameRW 帧包含了两个主要函数，WriteMsg() 用于发送数据，ReadMsg()用于读取数据；如下是 WriteMsg() 的代码片断：

1.  
   [./p2p/rlpx. go]
2.  
   func (rw *rlpxFrameRW) WriteMsg(msg Msg) error {
3.  
   ...
4.  
   // write header
5.  
   headbuf := make([]byte, 32)
6.  
   ...
7.  
   // write header MAC
8.  
   copy(headbuf[16:], updateMAC(rw.egressMAC, rw.macCipher, headbuf[:16]))
9.  
   if _, err := rw.conn.Write(headbuf); err != nil {
10.  
    return err
11.  
    }
12.  
     
13.  
    // write encrypted frame, updating the egress MAC hash with
14.  
    // the data written to conn.
15.  
    tee := cipher.StreamWriter{S: rw.enc, W: io.MultiWriter(rw.conn, rw.egressMAC)}
16.  
    if _, err := tee.Write(ptype); err != nil {
17.  
    return err
18.  
    }
19.  
    if _, err := io.Copy(tee, msg.Payload); err != nil {
20.  
    return err
21.  
    }
22.  
    if padding := fsize % 16; padding > 0 {
23.  
    if _, err := tee.Write(zero16[:16-padding]); err != nil {
24.  
    return err
25.  
    }
26.  
    }
27.  
     
28.  
    // write frame MAC. egress MAC hash is up to date because
29.  
    // frame content was written to it as well.
30.  
    fmacseed := rw.egressMAC.Sum( nil)
31.  
    mac := updateMAC(rw.egressMAC, rw.macCipher, fmacseed)
32.  
    _, err := rw.conn.Write(mac)
33.  
    return err
34.  
    }

结合以太坊 RLPX 的文档[2]和上述代码，能够分析出 RLPXFrameRW 帧的结构。在通常状况下，发送一次数据将产生五个数据包：

1.  
   header // 包含数据包大小和数据包源协议
2.  
   header_mac // 头部消息认证
3.  
   frame // 具体传输的内容
4.  
   padding // 使帧按字节对齐
5.  
   frame_mac // 用于消息认证

接收方按照一样的格式对数据包进行解析和验证。

0x06 RLP 编码

RLP编码 (递归长度前缀编码)提供了一种适用于任意二进制数据数组的编码，RLP 已经成为以太坊中对对象进行序列化的主要编码方式，便于对数据结构的解析。比起 json 数据格式，RLP 编码使用更少的字节。

在以太坊的网络模块中，全部的上层协议的数据包要交互给 p2p 链路时，都要首先经过 RLP 编码；从 p2p 链路读取数据，也要先进行解码才能操做。

以太坊中 RLP 的编码规则[3]。

0x07 LES 协议层

这里以 LES 协议为上层协议的表明，分析在以太坊网络架构中应用协议的工做原理。

LES 服务由 Geth 初始化时启动，调用源码 les 下的 NewLesServer() 函数开启一个 LES 服务并初始化，并经过 NewProtocolManager() 实现以太坊子协议的接口函数。其中 les/handle.go 包含了 LES 服务交互的大部分逻辑。

回顾上文 p2p 网络架构，最终 p2p 底层经过 p.Run() 启动协议，在 LES 协议中，也就是调用 LES 协议的 Run() 函数：

1.  
   [./les/handle. go#NewProtocolManager()]
2.  
   Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error {
3.  
   ...
4.  
   select {
5.  
   case manager.newPeerCh <- peer:
6.  
   ...
7.  
   err := manager.handle(peer)
8.  
   ...
9.  
   case <-manager.quitSync:
10.  
    ...
11.  
    }
12.  
    }

能够看到重要的处理逻辑都被包含在 handle() 函数中，handle() 函数的主要功能包含 LES 协议握手和消息处理，下面是 handle() 函数片断：

1.  
   [./les/handle.go]
2.  
   func (pm *ProtocolManager) handle(p *peer) error {
3.  
   ...
4.  
   if err := p.Handshake(td, hash, number, genesis.Hash(), pm.server); err != nil {
5.  
   p. Log().Debug("Light Ethereum handshake failed", "err", err)
6.  
   return err
7.  
   }
8.  
   ...
9.  
   for {
10.  
    if err := pm.handleMsg(p); err != nil {
11.  
    p. Log().Debug("Light Ethereum message handling failed", "err", err)
12.  
    return err
13.  
    }
14.  
    }
15.  
    }

在 handle() 函数中首先进行协议握手，其实现函数是 ./les/peer.go#Handshake()，经过服务端和客户端交换握手包，互相获取信息，其中包含有：协议版本、网络号、区块头哈希、创世块哈希等值。随后用无线循环处理通讯的数据，如下是报文处理的逻辑：

1.  
   [./les/handle. go]
2.  
   func (pm *ProtocolManager) handleMsg(p *peer) error {
3.  
   msg, err := p.rw.ReadMsg()
4.  
   ...
5.  
   switch msg.Code {
6.  
   case StatusMsg: ...
7.  
   case AnnounceMsg: ...
8.  
   case GetBlockHeadersMsg: ...
9.  
   case BlockHeadersMsg: ...
10.  
    case GetBlockBodiesMsg: ...
11.  
    ...
12.  
    }
13.  
    }

处理一个请求的详细流程是：

1. 使用 RLPXFrameRW 帧处理器，获取请求的数据。
2. 使用共享密钥解密数据。
3. 使用 RLP 编码将二进制数据序列化。
4. 经过对 msg.Code 的判断，执行相应的功能。
5. 对响应数据进行 RLP 编码，共享密钥加密，转换为 RLPXFrameRW，最后发送给请求方。

下面是 LES 协议处理流程：

0x08 总结

经过本文的分析，对以太坊网络架构有了大体的了解，便于后续的分析和代码审计；在安全方面来说，由协议所带的安全问题每每比本地的安全问题更为严重，应该对网络层面的安全问题给予更高的关注。

从本文也能够看到，以太坊网络架构很是的完善，具备极高的鲁棒性，这也证实了以太坊是能够被市场所承认的区块链系统。除此以外，因为 p2p 网络方向的资料较少，以太坊的网络架构也能够做为学习 p2p 网络的资料。