什么是日蚀攻击

首先简单介绍一下日蚀攻击

以太坊的节点发现机制基于Kademlia，但其目的却不同，Kademlia旨在成为在分布式对等网络中存储和查找内容的手段，而以太坊仅用于发现新的节点。由于以太坊的节点是由其公钥表示的，并且不受IP限制，因此在一个机器上可以同时存在很多节点。攻击者在很少的服务器上制作出很多的节点，并积极的ping受害者的服务器。通过Kademlia协议，攻击者的节点信息将存储并填充在受害者节点列表中。下一步就是让受害者重启机器，手段包括断电、ddos攻击等等。重启后，攻击者再不停的ping被害者的节点以建立tcp连接，一旦被害者所有的tcp连接都是攻击者制造的，那么就达到了把被害者与正常的网络隔离的目的，当然最大的目的应该还是为了双花。

网上有很多关于日蚀攻击的详细介绍，在这里不做赘述。

在刚才提到的论文中，提到了以太坊的geth1.8.0解决了日蚀攻击，于是作者拿1.8.0和1.7.3做对比，理清了以太坊解决这个问题的做法。

直接看代码。

以太坊启动时加载p2p网络的流程如下，

cmd/geth/main.go init方法-》 geth -》 startNode（） -》 utils.StartNode（） -》 stack.Start（） -》 running.Start（）

这个running.Start（）调用的即是p2p/server.go中的Start（）方法，看看这个方法做了什么：

// Start starts running the server.

// Servers can not be re-used after stopping.

func （srv *Server） Start（） （err error） {

srv.loopWG.Add（1）

go srv.run（dialer）

srv.running = true

return nil

}

这篇文章主要关注解决日蚀攻击相关代码，其他的不做介绍。

上面的go srv.run（dialer）连接池管理协程，负责维护TCP连接的列表，监听各种信号，处理peer的增删改

func （srv *Server） run（dialstate dialer） {

。..

running：

for {

scheduleTasks（）

select {

。..

case c ：= 《-srv.posthandshake：

// A connection has passed the encryption handshake so

// the remote identity is known （but hasn‘t been verified yet）。

if trusted［c.id］ {

// Ensure that the trusted flag is set before checking against MaxPeers.

c.flags |= trustedConn

}

// TODO： track in-progress inbound node IDs （pre-Peer） to avoid dialing them.

select {

case c.cont 《- srv.encHandshakeChecks（peers， inboundCount， c）：

case 《-srv.quit：

break running

}

case c ：= 《-srv.addpeer：

// At this point the connection is past the protocol handshake.

// Its capabilities are known and the remote identity is verified.

err ：= srv.protoHandshakeChecks（peers， inboundCount， c）

if err == nil {

// The handshakes are done and it passed all checks.

p ：= newPeer（c， srv.Protocols）

// If message events are enabled， pass the peerFeed

// to the peer

if srv.EnableMsgEvents {

p.events = &srv.peerFeed

}

name ：= truncateName（c.name）

srv.log.Debug（“Adding p2p peer”， “name”， name， “addr”， c.fd.RemoteAddr（）， “peers”， len（peers）+1）

go srv.runPeer（p）

peers［c.id］ = p

if p.Inbound（） {

inboundCount++

}

}

。..

case pd ：= 《-srv.delpeer：

// A peer disconnected.

d ：= common.PrettyDuration（mclock.Now（） - pd.created）

pd.log.Debug（“Removing p2p peer”， “duration”， d， “peers”， len（peers）-1， “req”， pd.requested， “err”， pd.err）

delete（peers， pd.ID（））

if pd.Inbound（） {

inboundCount--

}

}

}

。..

}

注意加粗的代码，有一个针对inboundCount的操作，当有posthandshake、addpeer消息的时候，会先去check，如果add或del了一个peer，则有对应的inboundCount++或者inboundCount--。看看到底check了什么：

protoHandshakeChecks最终也是调用encHandshakeChecks：

func （srv *Server） encHandshakeChecks（peers map［discover.NodeID］*Peer， inboundCount int， c *conn） error {

switch {

case ！c.is（trustedConn|staticDialedConn） && len（peers） 》= srv.MaxPeers：

return DiscTooManyPeers

case ！c.is（trustedConn） && c.is（inboundConn） && inboundCount 》= srv.maxInboundConns（）：

return DiscTooManyPeers

case peers［c.id］ ！= nil：

return DiscAlreadyConnected

case c.id == srv.Self（）.ID：

return DiscSelf

default：

return nil

}

}

inboundConn表示连接类型为主动连接过来。

看加粗的这段逻辑：如果该连接是信任的，且是主动连接过来的，且主动连接过来的节点数量大于srv.maxInboundConns（）时，则拒绝此连接。

可以看出来，以太坊是通过限制主动连接过来的数量来阻止日蚀攻击的。我们顺便看下这个数量是多少：

func （srv *Server） maxInboundConns（） int {

return srv.MaxPeers - srv.maxDialedConns（）

}

func （srv *Server） maxDialedConns（） int {

if srv.NoDiscovery || srv.NoDial {

return 0

}

r ：= srv.DialRatio

if r == 0 {

r = defaultDialRatio

}

return srv.MaxPeers / r

}

MaxPeers默认是25，defaultDialRatio表示能够接受主动连接的比例，默认是3，所以最多允许传入的tcp连接数量就是25/3 = 8个

『本文转载自网络,版权归原作者所有,如有侵权请联系删除』