How to enable
首先使用 ipfs-swarm-key-gen 生成 swarm.key
go get github.com/Kubuxu/go-ipfs-swarm-key-gen/ipfs-swarm-key-gen
ipfs-swarm-key-gen > ~/.ipfs/swarm.key
要加入一个私有网络首先要得到这个网络的 swarm.key 并保存到 ~/.ipfs/swarm.key 中，如果自定了 IPFS_PATH，那么就将它放入自定义的路径下。
当启用私网配置后，将无法再使用默认的 bootnode 了，需要设置为私网的 bootnode 。
为了防止私网节点尝试访问默认的 bootnode 我们先将其清除：
ipfs bootstrap rm --all
然后像这样来添加私网自己的 bootnode
ipfs bootstrap add
例如：
ipfs bootstrap add /ip4/104.236.76.40/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64
网络中的 bootnode 节点与其他节点没有任何不同，所以制作一个 bootnode 还是非常容易的。
也可以通过设置环境变量 LIBP2P_FORCE_PNET=1 来强行启用私网配置，如果没有正确配置 swarm.key 会导致 daemon 启动失败
- 参考资料 IPFS官方文档
原理分析
ipfs-swarm-key-gen
首先看看 key 是如何生成的
//github.com/Kubuxu/go-ipfs-swarm-key-gen/blob/master/ipfs-swarm-key-gen/main.go
func main() {
key := make([]byte, 32)
_, err := rand.Read(key)
if err != nil {
log.Fatalln("While trying to read random source:", err)
}
fmt.Println("/key/swarm/psk/1.0.0/")
fmt.Println("/base16/")
fmt.Print(hex.EncodeToString(key))
}
是不是太简单了？生成一个 32 位的随机数，用 hex.Encode 成一个 64 位 16进制数，谈下一话题。
How to use swarm.key
首先我们来看一下 libp2p 中的 pnet 接口和实现
- go-libp2p-interface-pnet
// go-libp2p-interface-pnet/interface.go
// Protector interface is a way for private network implementation to be transparent in
// libp2p. It is created by implementation and use by libp2p-conn to secure connections
// so they can be only established with selected number of peers.
type Protector interface {
// Wraps passed connection to protect it
Protect(net.Conn) (net.Conn, error)
// Returns key fingerprint that is safe to expose
Fingerprint() []byte
}
Protector 接口说它是实现私网的一种方式，由 libp2p-conn 调用创建加密连接
- go-libp2p-pnet
// go-libp2p-pnet/protector.go
type protector struct {
psk *[32]byte
fingerprint []byte
}
func (p protector) Protect(in net.Conn) (net.Conn, error) {
return newPSKConn(p.psk, in)
}
func (p protector) Fingerprint() []byte {
return p.fingerprint
}
这个 protector 类实现了 Protector 接口，在创建这个类时会去反序列化 key 得到 psk ，那个就不重要了，比较重要的是 newPSKConn 这个包装
func newPSKConn(psk *[32]byte, insecure net.Conn) (net.Conn, error) {
if insecure == nil {
return nil, errInsecureNil
}
if psk == nil {
return nil, errPSKNil
}
return &pskConn{
Conn: insecure,
psk: psk,
}, nil
}
上面的 newPSKConn 返回了 pskConn ，这个类继承了 net.Conn并且对 read 和 write 进行了有关加密解密的封装
type pskConn struct {
net.Conn
psk *[32]byte
writeS20 cipher.Stream
readS20 cipher.Stream
}
func (c *pskConn) Read(out []byte) (int, error) {
if c.readS20 == nil {
// 如果是第一个包，那么前 24 个字节一定是一个随机数
// 因为下面的 Write 方法第一个包就是放了一个 24 byte 的 nonce 在前面
nonce := make([]byte, 24)
_, err := io.ReadFull(c.Conn, nonce)
if err != nil {
return 0, errShortNonce
}
// salsa20.New 这个实现过程比较复杂，目的是返回一个标准库中 cipher.Stream 接口的实现类
c.readS20 = salsa20.New(c.psk, nonce)
}
maxn := uint32(len(out))
in := mpool.ByteSlicePool.Get(maxn).([]byte) // get buffer
defer mpool.ByteSlicePool.Put(maxn, in) // put the buffer back
in = in[:maxn] // truncate to required length
n, err := c.Conn.Read(in) // read to in
if n > 0 {
// 代码看到这里就可以省略后面的处理了，因为答案已经出来了
// 直接去看标准库中对于 cipher.Stream.XORKeyStream 的定义即可
c.readS20.XORKeyStream(out[:n], in[:n]) // decrypt to out buffer
}
return n, err
}
func (c *pskConn) Write(in []byte) (int, error) {
......
c.writeS20.XORKeyStream(out, in) // encrypt
return c.Conn.Write(out) // send
}
从 Read 和 Write 的实现中看到了 XORKeyStream ，字面能猜出这是通过数据包和 key 进行异或操作而实现的简单的加密传输，两边的key肯定是一致的，并且每次建立连接时都会交换一个 24 位的 nonce，细心的同学可以去看一下具体的拆分逻辑，分成了 前16 和后 8 ，又做了一些复杂的位移操作用来生成连接通道上使用的key，随机数保证了每次连接通道上的 key 都是不同的。
谁在使用 Protector ?
- 答案：go-libp2p-transport-upgrader
在 libp2p 中定义了很多 Option 用来初始化 Host 对象，在前面的几篇入门文章中提及过，其中就有一个叫 libp2p.PrivateNetwork 的 option，用来为 Host 指定 Protector 。前面的文章也提到过 TcpTransport 到 Upgrader 的调用过程，这个 Protector 就是在 Upgrader.upgrade 中被使用到的，有兴趣的同学可以重新回忆并翻找一下代码。
总结
现在我们知道了私网是通过对通道进行加密来建立的，发出的数据包都用密钥进行一次异或 XOR(packet,securityKey) ，接收端再做一次相同的操作即可还原数据包。这个原理计算机专业的同学应该都了解，如果不了解就演算一下
- 演算过程： 设 packet = 1 , securityKey = 1
securityPacket = xor(packet, securityKey) = xor(1,1) = 0
packet = xor(securityPacket,securityKey) = xor(0,1) = 1
原文链接：https://www.jianshu.com/p/dfc61136324c