grpc-go源码剖析九十三之数据帧发送阶段来分析grpc框架加密的原理？
本小节主要是介绍使用tls链路传输时，是如何对数据帧进行加密的？
我们以客户端一侧发送数据帧为例。
假设，将创建好的数据帧交由帧发送器进行发送，看看是如何对数据帧进行加密的？
| 1、分析入口？帧发送器里的processData |
分析入口是grpc-go/internal/transport/controlbuf.go文件中的processData方法里：
func (l *loopyWriter) processData() (bool, error) {
//---省略不相关代码
err := l.framer.fr.WriteData(dataItem.streamID, endStream, buf[:size]);
//---省略不相关代码
主要调用链，可参考下面：
WriteData→WriteDataPadded→f.endWrite()→f.w.Write(f.wbuf)
最终进入go/1.15.5/libexec/src/crypto/tls/conn.go文件中Conn结构下的Write方法里：
1．func (c *Conn) Write(b []byte) (int, error) {
2． for {
3． //---省略不相关代码
4． if err := c.Handshake(); err != nil {
5． return 0, err
6． }
7． //---省略不相关代码
8． n, err := c.writeRecordLocked(recordTypeApplicationData, b)
9． return n + m, c.out.setErrorLocked(err)
10．}
主要流程说明：
- 第4行：进行握手协议，内部会判断，如果已经进行过握手的话，就不会再次握手了。
- 第8行：调用writeRecordLocked发送数据帧，b就是创建好的数据帧。数据的类型是ApplicationData
| 2、数据帧dataFame的加密过程encrypt |
进入go/1.15.5/libexec/src/crypto/tls/conn.go文件中writeRecordLocked结构下的
1．func (c *Conn) writeRecordLocked(typ recordType, data []byte) (int, error) {
2． var n int
3． for len(data) > 0 {
4． m := len(data)
//---省略不相关代码
5． _, c.outBuf = sliceForAppend(c.outBuf[:0], recordHeaderLen)
6． c.outBuf[0] = byte(typ)
7． vers := c.vers
8． if vers == 0 {
9． vers = VersionTLS10
10． } else if vers == VersionTLS13 {
11． vers = VersionTLS12
12． }
13． c.outBuf[1] = byte(vers >> 8)
14． c.outBuf[2] = byte(vers)
15． c.outBuf[3] = byte(m >> 8)
16． c.outBuf[4] = byte(m)
17． var err error
18． log.Infof("-----mdata---------m----1:%d\tdata1:%v", m, string(data))
19． c.outBuf, err = c.out.encrypt(c.outBuf, data[:m], c.config.rand())
20． if err != nil {
21． return n, err
22． }
23． outbufs := hex.EncodeToString(c.outBuf)
24． log.Infof("-----mdata---------m---2:%d\tdata2:%v", m, outbufs)
25． if _, err := c.write(c.outBuf); err != nil {
26． return n, err
27． }
28． //---省略不相关代码
29．}
主要流程说明：
- 第4行：获取一下数据帧的大小;data就是待发送的数据帧。
- 第5行：创建一个切片c.outBuf,用来存储加密后的数据
- 第6-16行：就是实现一种数据格式，规定好第一位代表什么，第二位代表什么等等；然后接收端会按照定义好的数据格式进行解析；比方说第1位代表的是数据类型。
- 第18行：是测试用的打印语句，测试加密前的原内容是什么
- 第19行：开始加密；
- 第23-24行：用于测试加密后的内容，将存储加密后的切片转化为16进制的字符串
- 第25行：使用write，将加密后的数据发送出去
| 2.1、根据类型选择加密算法？ |
我们只关心第19行encrypt方法：
进入go/1.15.5/libexec/src/crypto/tls/conn.go文件中halfConn结构体下的encrypt方法里：
1．func (hc *halfConn) encrypt(record, payload []byte, rand io.Reader) ([]byte, error) {
2． //---省略不重要代码
3． switch c := hc.cipher.(type) {
4． case cipher.Stream:
5． //---省略不相关代码
6． case aead:
7． nonce := explicitNonce
8． if len(nonce) == 0 {
9． nonce = hc.seq[:]
10． }
11． if hc.version == VersionTLS13 {
12． record = append(record, payload...)
13． record = append(record, record[0])
14． record[0] = byte(recordTypeApplicationData)
15． n := len(payload) + 1 + c.Overhead()
16． record[3] = byte(n >> 8)
17． record[4] = byte(n)
18． record = c.Seal(record[:recordHeaderLen],
19． nonce, record[recordHeaderLen:], record[:recordHeaderLen])
20． } else {
21． copy(hc.additionalData[:], hc.seq[:])
22． copy(hc.additionalData[8:], record)
23． record = c.Seal(record, nonce, payload, hc.additionalData[:])
24． }
25． case cbcMode:
26． //---省略不相关代码
27． default:
28． panic("unknown cipher type")
29． }
30．//---省略不相关代码
31． return record, nil
32．}
主要流程说明：
- 第3-29行：根据hc.cipher类型，来触发不同的流程；我们主要分析aead类型,即关联数据的认证加密。
- 第11-24行：根据tls版本来触发不同的分支；最终目的都是调用Seal方法；假设我们使用的是tls1.3版本
- 第12-17行：构建一个固定格式的切片record；具体格式内容，可以不用关心，我们只关心传输数据时，到底有没有加密；
- 第18行：调用Seal方法，进行加密。
- 第11-24行：根据tls版本来触发不同的分支；最终目的都是调用Seal方法；假设我们使用的是tls1.3版本
| 2.2、如何创建cipher?如何使用在tls链路建立阶段双方协商好的数据作为加密数据的？ |
调用Seal其实，也就是调用的cipher的Seal方法
因此，需要知道cipher在什么地方进行的初始化？
进入go/1.15.5/libexec/src/crypto/tls/handshake_client_tls13.go文件中的clientHandshakeStateTLS13结构体下的handshake方法里：
(也就是进入到了客户端跟服务器端tcp链路建立后的握手阶段)
1．func (hs *clientHandshakeStateTLS13) handshake() error {
2． //---省略不相关代码
3． if err := hs.processServerHello(); err != nil {
4． return err
5． }
6． if err := hs.sendDummyChangeCipherSpec(); err != nil {
7． return err
8． }
9． if err := hs.establishHandshakeKeys(); err != nil {
10． return err
11． }
12． //---省略不相关代码
我们只关心第9行的establishHandshakeKeys方法，
进入go/1.15.5/libexec/src/crypto/tls/handshake_client_tls13.go文件中的establishHandshakeKeys方法里:
1．func (hs *clientHandshakeStateTLS13) establishHandshakeKeys() error {
2． c := hs.c
3． sharedKey := hs.ecdheParams.SharedKey(hs.serverHello.serverShare.data)
4． //---省略不相关代码
5． handshakeSecret := hs.suite.extract(sharedKey,
6． hs.suite.deriveSecret(earlySecret, "derived", nil))
7． //---省略不相关代码
8． clientSecret := hs.suite.deriveSecret(handshakeSecret,
9． clientHandshakeTrafficLabel, hs.transcript)
10． c.out.setTrafficSecret(hs.suite, clientSecret)
主要流程说明：
- 第3行：根据服务器端传输过来的serverShare.data数据，创建出sharedKey，也就是说，客户端跟服务器端协商了一个公共的数据。
- 第5行：根据sharedKey数据又生成一个handshakeSecret
- 第8行：根据handshakeSecret 生成clientSecret; 这个数据可以作为传输数据帧时用的加密数据。
- 第10行：将clientSecret数据，设置到加密套件里hs.suite
进入setTrafficSecret方法里：
1．func (hc *halfConn) setTrafficSecret(suite *cipherSuiteTLS13, secret []byte) {
2． hc.trafficSecret = secret
3． key, iv := suite.trafficKey(secret)
4． hc.cipher = suite.aead(key, iv)
5． for i := range hc.seq {
6． hc.seq[i] = 0
7． }
8．}
主要流程说明：
- 第1行：参数secret就是clientSecret
- 第3行：将clientSecret转换为了key,iv
- 第4行：将key,iv作为参数，调用suite.aead函数；
点击suite.aead函数，进入到go/1.15.5/libexec/src/crypto/tls/cipher_suites.go文件中的cipherSuiteTLS13结构体里：
type cipherSuiteTLS13 struct {
id uint16
keyLen int
aead func(key, fixedNonce []byte) aead
hash crypto.Hash
}
aead就是一个函数类型，返还的是aead;
进入到go/1.15.5/libexec/src/crypto/tls/cipher_suites.go文件中aeadAESGCMTLS13函数里：
1．func aeadAESGCMTLS13(key, nonceMask []byte) aead {
2． if len(nonceMask) != aeadNonceLength {
3． panic("tls: internal error: wrong nonce length")
4． }
5． aes, err := aes.NewCipher(key)
6． if err != nil {
7． panic(err)
8． }
9． aead, err := cipher.NewGCM(aes)
10． if err != nil {
11． panic(err)
12． }
13． ret := &xorNonceAEAD{aead: aead}
14． copy(ret.nonceMask[:], nonceMask)
15． return ret
16．}
其中参数key里暗含着clientSecret数据；
经过第5行，第9行，第13行的转换，
那么，第13行中的aead同样暗含着clientSecret数据。
最终将clientSecret数据封装到了xorNonceAEAD结构体里。
其实，setTrafficSecret方法中的hc.cipher = suite.aead(key, iv)语句的最终结果，hc.cipher就是xorNonceAEAD
此时，已经知道了使用哪个加密算法，以及协商好的加密数据，接下来，就是开始真正的对数据帧进行加密了。
| 2.3、使用加密算法以及协商好的加密数据开始对数据帧真正加密？ |
此时，我们返回到go/1.15.5/libexec/src/crypto/tls/conn.go文件中的halfConn结构体下的encrypt方法里，
调用Seal方法，也就是调用的xorNonceAEAD结构体的Seal方法；
因此，我们进入go/1.15.5/libexec/src/crypto/tls/cipher_suites.go文件中xorNonceAEAD结构体下的Seal方法里：
1．func (f *xorNonceAEAD) Seal(out, nonce, plaintext, additionalData []byte) []byte {
2． for i, b := range nonce {
3． f.nonceMask[4+i] ^= b
4． }
5． result := f.aead.Seal(out, f.nonceMask[:], plaintext, additionalData)
6． for i, b := range nonce {
7． f.nonceMask[4+i] ^= b
8． }
9． return result
10．}
我们只关注第5行，其中f.aead里存储着客户端跟服务器端tls链路建立时协商好的数据，如在客户端一侧，协商好的最终数据是clientSecret，
此时第5行在调用Seal时，会用到clientSecret，具体就不再看了。
到目前为止，我们介绍完了数据帧在传输阶段确实加密了，加密时用到了tls链路建立阶段双方协商好的一段数据，用以加密。
下一篇文章
如何理解认证token？