前言

撰写本文时TLS1.3 RFC 已经发布到28版本。以前写过一点密码学及TLS 相关的文章，为了更深入理解TLS1.3协议，这次将尝试使用Go语言实现它。网络上已有部分站点支持TLS1.3，Chrome浏览器通过设置可支持TLS1.3 (draft23)，利用这些条件可验证，我们实现的协议是否标准。

完整的实现TLS1.3 工作量很大，概念和细节非常多（感觉又在挖坑）。本文首先会从ClientHello开始,后续可能会考虑：Authentication、Cryptographic Computations、0-RTT 。

5G 未来

每次基础设施的升级都是时代变革的前奏。在移动互联网2G/3G时代，很多创新都约束在了Wifi 下；移动互联网进入4G时代后，爆发了各种直播、短视频等创新。现在的IOT和移动互联网上半场略有相似，待5G成熟万物互联后，相信也会爆发出一系列的创新。

网络互连后信息的安全传输，也是不容忽视的问题。TLS1.3 相对于之前的版本,修正了很多安全陷阱，降低了握手的次数，提高了效率。

私有化

TLS1.3 中有不少设计是为了向下兼容TLS1.2 或TLS1.1 (毕竟是公开的网络协议)，如果想要建立一个私有化的安全层，只要按照标准里的要点，可以剔除其中兼容性的设计，优化包结构减少数据传输量。例如参考以太坊的RLP编码方式，将长度和数据结合在一起，就可以进一步减少包大小。

利用TLS1.3建立一个安全高效的 “安全会话层”,
1、往下可以增加连接管理模块、心跳控制模块，如：实现多级TCP 通道快速重连重发等，解决弱网状态下的各种问题。
2、往上可以服务各种不同的网络类型如p2p或经典C/S,
3、更上层可以服务一些中间件如： RPC 、MQTT等支撑业务。

connect.001.jpeg

下面我们将尽可能的参照TLS1.3定义的结构编写代码，同时利用Wireshark 抓包查看包情况。

从ClientHello开始

TLS1.3 的握手流程由客户端发送ClientHello 开始，该消息携带密钥协商必要的数据。服务器端收到该消息后回复ServerHello。我们将向一个启用了TLS1.3 协议的站点发送，自己实现的 ClientHello 消息，看能否收到 ServerHello回复。

先看结果

上图是Wireshark 的抓包结果，ali-BF 是我本机电脑，Server是某台启用TLS1.3的网络服务器。

从图中可以看到三次tcp 握手后，我们发出ClientHello 消息长度348个字节，经过一个ack后成功收到 Server Hello 消息。

编码实现

TLS1.3 包含一系列子协议，如 Record Protocol、Handshake Protocol 、Alert Protocol 、ApplicationData Protocol 等
三者关系如图：

发送一个ClientHello 至少需要实现以下模块

Record 层

ClientHello 是明文传输的，所以是封装在TLSPlaintext 中

// ContentType enum {...} ;
type ContentType byte

const (
    invalid          ContentType = 0
    changeCipherSpec ContentType = 20
    alert            ContentType = 21
    handshake        ContentType = 22
    applicationData  ContentType = 23
)

// TLSPlaintext plaintext on record layer
type TLSPlaintext struct {
    contentType         ContentType
    legacyRecordVersion ProtocolVersion //static
    length              uint16
    fragment            syntax.Vector
}

type TLSCiphertext TLSPlaintext

legacyRecordVersion 的值为0x0303 为了兼容TLS1.2版。

定义一个接口用于序列化,后面所有的Struct 都会实现该接口

type Encoder interface {
    //Encode coding object into the Writer,
    Encode(w io.Writer)  error

    //ByteCount return the byte length of all Object
    ByteCount() int
}

type Vector Encoder

序列化TLSPlaintext


func generateTLSPlaintext(contentType ContentType, fragment syntax.Vector) TLSPlaintext {
    return TLSPlaintext{
        contentType:         contentType,
        legacyRecordVersion: TLS1_2,
        length:              uint16(fragment.ByteCount()),
        fragment:            fragment,
    }
}

func (t *TLSPlaintext) Encode(w io.Writer) error {

    if uint16(t.length) > 2<<14 {
        return errors.New("overflow fragment")
    }
    err := syntax.Encode(w,
        syntax.WriteTo(t.contentType),
        syntax.WriteTo(t.legacyRecordVersion),
        syntax.WriteTo(t.length))
    if err != nil {
        return err
    }
    err = t.fragment.Encode(w)
    return err
}

func (t *TLSPlaintext) ByteCount() int {
    return t.fragment.ByteCount() + 5
}

本文的主要目的是深入浅出的学习TLS1.3协议，因此在实现上并不是很关注性能和效率问题及部分异常情况。

Handshake

TLS1.3 支持三种方式的密钥协商：PSK-Only、(EC)DHE，和PSK with (EC)DHE ,本文主要是关注 ECDHE。
Handshake 对应了TLSPlaintext 的fragment ，因为其实现了Vector 接口


type Handshake struct {
    msgType       HandshakeType /* handshake type */
    length        uint24
    handshakeData syntax.Vector
}

func generateHandshake(msgType HandshakeType, data syntax.Vector) Handshake {
    l := data.ByteCount()
    return Handshake{
        msgType:       msgType,
        length:        uint24{byte(l >> 16), byte(l >> 8), byte(l)},
        handshakeData: data,
    }
}

ClientHello

ClientHello 对应Handshake的handshakeData 。

type extensionsVector struct {
    length     uint16
    extensions []extension.Extension
}

type ClientHello struct {
    legacyVersion            tls.ProtocolVersion
    random                   [32]byte
    legacySessionId          legacySessionId
    cipherSuites             CipherSuiteVector
    legacyCompressionMethods legacyCompressionMethods
    extensions               extensionsVector
}

legacyVersion 、legacySessionIdlegacyCompressionMethods 的定义是为了兼容旧版本，因此需要的是random 、 cipherSuites 和 extensions.

CipherSuite 指明了Client所能支持的加密套件例如：TLS_AES_128_GCM_SHA256、TLS_AES_256_GCM_SHA384等，只支持 AEAD 的加密算法套件。

func generateClientHello(cipherSuites []CipherSuite, exts ...extension.Extension) ClientHello {
    var r [32]byte
    rand.Read(r[:])
    extBytes := 0
    for _, ext := range exts {
        extBytes += ext.ByteCount()
    }
    return ClientHello{
        legacyVersion:            tls.TLS1_2,
        random:                   r,
        legacySessionId:          legacySessionId{0, nil},
        cipherSuites:             NewCipherSuite(cipherSuites...),
        legacyCompressionMethods: generateLegacyCompressionMethods([]byte{0}),
        extensions:               generateExtensions(exts...),
    }
}

func generateExtensions(exts ...extension.Extension) extensionsVector {
    l := 0
    for _, ext := range exts {
        l += ext.ByteCount()
    }
    return extensionsVector{
        length:     uint16(l),
        extensions: exts,
    }
}

func NewClientHelloHandshake(cipherSuites []CipherSuite, exts ...extension.Extension) Handshake {
    cl := generateClientHello(cipherSuites, exts...)
    return generateHandshake(clientHello, &cl)
}

各种Extension

ClientHello 主要是通过Extension 传递密钥协商必要的素材，第一次ClientHello 至少需要包含以下5个Extension：
1、ServerName : 所请求的主机名

通常情况下一台服务器会寄宿多个站点，即同一个IP 多个Web服务器。由于TLS 层还未完成握手，此时还没有http的请求(host head)，无法知道具体站点。后续握手时服务器端将难以确定要发送的证书。

虽然采用通用名和subjectAltName的方式可以支持多个域名，但是无法得知未来所有的域名，一旦有变更还得重新申请证书。因此在ClientHello中添加ServerName扩展用于指明要访问的主机，查看详情RFC6066。

这样做有个缺点，ClientHello 是明文传输，中间人可以明确探知该流量的目的地。像WhatApp 和 Signal 就采用一种叫“域前置” 的技术去绕过该问题。

2、SupportedVersions :所能支持的TLS 版本如：TLS1.1、TLS1.2、TLS1.3等

用于协商最终采用的TLS 版本，在ClientHello 所能支持的列表，把最优先支持的放在第一位。

3、SignatureAlgorithms : 所支持的签名算法

如：ECDSA_SECP256R1_SHA256、ECDSA_SECP384R1_SHA384等

4、SupportedGroups:用于密钥交换

本文主要关注椭圆曲线如：SECP256R1、SECP384R1、SECP521R1等

5、KeyShare:密钥协商时交换的公钥

每一个SupportedGroup 需要有对应的 KeyShare。

Extension Golang实现

Extension 基本是才有 Request/Response 方式通讯，客户端发送Request、服务器端通过Response 的方式回复所选。

type Extension struct {
    extensionType ExtensionType
    length        uint16
    extensionData syntax.Vector
}

下面将列出SupportedVersions 和 KeyShare 的golang 实现，其他Extension 的实现比较相似。

ClientHello 的SupportedVersions 比较简单，只要包含一个ProtocolVersions数组即可。

type SupportedVersions struct {
    length           uint8 // byte count of array protocolVersions
    protocolVersions []tls.ProtocolVersion
}

func generateSupportedVersions(protocolVersions ...tls.ProtocolVersion) SupportedVersions {
    return SupportedVersions{
        length:           uint8(len(protocolVersions) * 2),
        protocolVersions: protocolVersions,
    }
}

//NewSupportedVersionsExtension create a supported versions extension
func NewSupportedVersionsExtension(protocolVersions ...tls.ProtocolVersion) Extension {
    sv := generateSupportedVersions(protocolVersions...)
    return generateExtension(supportedVersions, &sv)
}

本文将以ECC 的P-256、P-384 、P-521曲线作为实现，说明如果生成对应的KeyShare

type KeyShareEntry struct {
    group       NamedGroup
    length      uint16
    keyExchange []byte
}

func generateKeyShareEntry(group NamedGroup) (KeyShareEntry, []byte) {
    var curve elliptic.Curve
    switch group {
    case SECP256R1:
        curve = elliptic.P256()
        break
    case SECP384R1:
        curve = elliptic.P384()
        break
    case SECP521R1:
        curve = elliptic.P521() 
        break
    }

    priv, x, y, err := elliptic.GenerateKey(curve, rand.Reader)
    if err != nil {
        return KeyShareEntry{}, nil
    }

    nu := generateUncompressedPointRepresentation(x.Bytes(), y.Bytes())
    buffer := new(bytes.Buffer)
    nu.Encode(buffer)

    ks := KeyShareEntry{
        group:       group,
        length:      uint16(len(nu.X)+len(nu.Y)) + 1,
        keyExchange: buffer.Bytes(),
    }
    return ks, priv
}

type KeyShareClientHello struct {
    length       uint16
    clientShares []KeyShareEntry
}

func generateKeyShareClientHello(enters ...KeyShareEntry) KeyShareClientHello {
    var l uint16
    for _, k := range enters {
        l += k.length + 4
    }
    return KeyShareClientHello{
        length:       l,
        clientShares: enters,
    }
}

func NewKeyShareClientExtension(groups ...NamedGroup) (Extension, [][]byte) {

    keyShareList := make([]KeyShareEntry, len(groups))
    privateList := make([][]byte, len(groups))
    for i, g := range groups {
        ks, priv := generateKeyShareEntry(g)
        keyShareList[i] = ks
        privateList[i] = priv
    }

    kscl := generateKeyShareClientHello(keyShareList...)
    return generateExtension(keyShare, &kscl), privateList

}

type UncompressedPointRepresentation struct {
    legacyForm uint8
    X          []byte
    Y          []byte
}

func generateUncompressedPointRepresentation(x, y []byte) UncompressedPointRepresentation {
    return UncompressedPointRepresentation{
        legacyForm: 4,
        X:          x,
        Y:          y,
    }
}

发送ClientHello

组合上面的各种类型，构建ClientHello ,编码后发送给远端服务器（真实存在的站点），TLS1.3 采用的是大端字节序。

func firstClientHello(conn net.Conn, host string) {
    supportedVersion := extension.NewSupportedVersionsExtension(tls.TLS1_3)
    supportedGroup := extension.NewSupportedGroupExtension(extension.SECP256R1, extension.SECP384R1)
    keyShare, _ := extension.NewKeyShareClientExtension(extension.SECP256R1, extension.SECP384R1)
    signatureScheme := extension.NewSignatureSchemeExtension(extension.ECDSA_SECP256R1_SHA256, extension.ECDSA_SECP384R1_SHA384)
    serverName := extension.NewServerNameExtension(host)

    clientHelloHandshake := handshake.NewClientHelloHandshake([]handshake.CipherSuite{
        handshake.TLS_AES_128_GCM_SHA256,
        handshake.TLS_AES_128_CCM_SHA256,
        handshake.TLS_AES_256_GCM_SHA384}, serverName, supportedVersion, signatureScheme, supportedGroup, keyShare)

    clientHelloRecord := tls.NewHandshakeRecord(&clientHelloHandshake)
    clientHelloRecord.Encode(outputBuffer)
    _, err := outputBuffer.WriteTo(conn)
    if err != nil {
        fmt.Println(err)
        return
    }
}

查看Wireshark的抓包数据

包含了我们所构建的数据和几个Extenison

Server端的回复：

可以看到 Server 选择了 AES_256_GCM_SHA384 加密套件、KeyShare 选择了 p-256曲线。同时发现服务器端已开始传输部分加密的数据 “ApplicationData” 。

读懂TLS1.3的数据结构

全英文的 TLS1.3 RFC 阅读起来很吃力。为了能较好的理解协议（以及其引用的一系列RFC ）需要先了解其标记语言

Presentation Language

TLS1.3 定义了一些Presentation Language 来描述数据的结构和序列化方式。

1、类型的别名 T T'
T' 为T的类型别名
如:uint16 ProtocolVersion ， ProtocolVersion 就是 uint16 的别名，它表明ProtocolVersion在传输中占有2个字节。golang 中的定义：

type ProtocolVersion uint16

2、定长数组类型 T T'[n]
T'[] 表示为T的数组，需要注意的是n并不代表T的个数，而是T'类型占用多少个byte，
如： opaque Random[32] ，表示 Random 类型占用了32 个字节。opaque 表示不透明的数据结构，可以理解为byte数组

3、可变长度数组类型 T T'
T'<> 包含两部分： head+body,
head的值表示body 占用了多少个字节，
body的值为真实负载，即T的数组。 head 本身所占的字节数由决定。
如：
CipherSuite cipher_suites<2..2^16-2>
表示 CipherSuite 类型的数组，其head 占用 2byte, uint16可以容下2^16个字节。

在golang 中可以这样表示

type CipherSuiteVector struct {
    length       uint16
    cipherSuites []CipherSuite
}

4、枚举类型 enum { e1(v1), e2(v2), ... , en(vn) [[, (n)]] } Te;
e1表示枚举类型的值。最后的 [[,(n)]] n 表示最大值，由此可以推论出枚举类型 Te 占用的字节数
如：

enum {
          client_hello(1),
          server_hello(2),
          new_session_ticket(4),
          end_of_early_data(5),
          encrypted_extensions(8),
          certificate(11),
          certificate_request(13),
          certificate_verify(15),
          finished(20),
          key_update(24),
          message_hash(254),
          (255)
      } HandshakeType;

HandshakeType 类型占一个byte 2^8
在golang 中可以这样定义

// HandshakeType alies
type HandshakeType byte

const (
    clientHello         HandshakeType = 1
    serverHello         HandshakeType = 2
    newSessionTicket    HandshakeType = 4
    endOfEarlyData      HandshakeType = 5
    encryptedExtensions HandshakeType = 8
    certificate         HandshakeType = 11
    certificateRequest  HandshakeType = 13
    certificateVerify   HandshakeType = 15
    finished            HandshakeType = 20
    keyUpdate           HandshakeType = 24
    messageHash         HandshakeType = 254
)

5、常量表示
在TLS 1.3 中协议中有些字段必须设置为固定值，主要是为了兼容旧版本，因此需要定义常量的表示。

struct {
          T1 f1 = 8;  /* T.f1 must always be 8 */
          T2 f2;
      } T;

这里 T.f1 的值固定为8
例如:

struct {
          ProtocolVersion legacy_version = 0x0303;    /* TLS v1.2 */
          Random random;
          opaque legacy_session_id<0..32>;
          CipherSuite cipher_suites<2..2^16-2>;
          opaque legacy_compression_methods<1..2^8-1>;
          Extension extensions<8..2^16-1>;
      } ClientHello;

ClientHello.legacy_version 的值固定为 0x0303 ，为了向下兼容。

6、变量定义

struct {
          T1 f1;
          T2 f2;
          ....
          Tn fn;
          select (E) {
              case e1: Te1 [[fe1]];
              case e2: Te2 [[fe2]];
              ....
              case en: Ten [[fen]];
          };
      } Tv;

Tv.E 是变量，跟进具体的情况取值。
例如

struct {
          select (Handshake.msg_type) {
              case client_hello:
                   ProtocolVersion versions<2..254>;

              case server_hello: /* and HelloRetryRequest */
                   ProtocolVersion selected_version;
          };
} SupportedVersions;

这里如果是在ClientHello 里 SupportedVersions 则是一个 Vector 类型，而在ServerHello 里则是一个ProtocolVersion

TLS1.3 协议的Golang 实现——ClientHello

前言

5G 未来

私有化

从ClientHello开始

先看结果

编码实现

Record 层

Handshake

ClientHello

各种Extension

Extension Golang实现

发送ClientHello

读懂TLS1.3的数据结构

Presentation Language

热门文章

最新文章

相关电子书

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

TLS1.3 协议的Golang 实现——ClientHello

前言

5G 未来

私有化

从ClientHello开始

先看结果

编码实现

Record 层

Handshake

ClientHello

各种Extension

Extension Golang实现

发送ClientHello

读懂TLS1.3的数据结构

Presentation Language

热门文章

最新文章

相关电子书

推荐镜像