标签 加密 下的文章

通过实例理解Web应用用户密码存储方案

本文永久链接 – https://tonybai.com/2023/10/25/understand-password-storage-of-web-app-by-example

在上一篇文章《通过实例理解Go Web身份认证的几种方式》中,我们了解了Web应用的多种身份验证方式。但无论哪种方式,用户初次访问Web应用的注册流程和登录流程是不可避免的,而基于用户名密码的注册流程依旧是当今主流。注册后,Web应用后端是如何保存用户密码的呢?历史上都有哪些存储方案?当今的主流存储方案又是什么呢?在这篇文章中,我们就来说说Web应用的各种密码存储方案的优缺点,并通过实例来理解一下当前的主流存储方案。

1. Web应用用户密码存储的重要性

用户密码是访问Web应用的关键,它直接关乎到用户账号和应用数据的安全。

如果用户密码被泄露或破解,将导致严重后果。后果最轻的算是某个用户或某少数用户的账号被盗用了,用户将失去对账号的控制。盗用账号后,攻击者可以获取该用户的私密信息,或进行额外的攻击;如果用户在多个应用重复使用同一密码,那么后果将进一步严重,用户的一系列账号都将受到安全威胁;更为严重的是Web应用存储用户账号信息的数据库被攻破(俗称“脱库”),攻击者会拿到存储的全部用户账号信息等,如果用户密码存储不当,攻击者可以很容易破译所有用户的密码,并基于这些密码信息做进一步的攻击。

由此可见,Web应用必须非常重视用户密码的存储安全。在当前弱密码和频繁密码泄露成为常态的背景下,Web应用开发者有责任使用安全的密码存储方案,尽力保护用户信息安全,即便在被脱库的最糟糕情况下,也不让攻击者轻易破解出用户的密码,这也关系到应用和企业的信誉。

2. 密码存储方案的演进:魔高一尺,道高一丈

Web应用用户密码存储方案的演进历史可以分为以下几个阶段,如图所示:

下面我们按图中的演进顺序,对各阶段的密码存储方案逐一说明一下。

2.1 起始阶段 – 明文存储

早期的Web应用为了实现简单,采用了最简单“粗暴”的用户密码存储方式:明文存储,即直接把用户的密码以纯文本形式存储在数据库中。

显然这种方式的最大优点就是实现简单,验证登录时直接比对明文密码。但这种方式最大的缺点就是极其不安全,密码一旦泄露就失去了全部保密性。但当时人们的安全意识较弱,该方案被广泛使用。

2.2 弱哈希算法阶段 – MD5和SHA1

随着时间的推移,CPU和GPU性能的提升使得字典破解和穷举攻击更加可行有效,大量密码被泄露的事件引起人们对密码安全的重视,人们更多地认识到明文存储密码的危险性。同时,Web应用的发展也从追求功能和便利,转变为在易用性与安全性之间求平衡。政府和行业协会也开始指定密码存储的最新安全要求的规范和政策,密码学等相关技术的快速发展也为更安全的密码存储提供了前提和支持。

于是人们开始使用MD5、SHA1等单向哈希算法对密码进行处理,只存储密码的哈希值。虽然增加了一定的密码存储的复杂性,但其最大的优点就是在一定程度上放置了明文存储的密码泄露问题。

不过,随着大量使用MD5和SHA-1的应用遭到破解,这些哈希算法的脆弱性暴露无遗。同时彩虹表攻击的出现,让破解者只需要预计算密码哈希表就可以快速破解以弱哈希存储的密码。

于是技术社区以及安全规范都开始提倡和推荐采用更安全的密码存储方案,即采用加盐方案

2.3 加盐哈希阶段 – 增加随机盐值

加盐哈希就是在计算密码的哈希值时,在密码字符串前/后面添加一个称为“盐(salt)”的随机字符串,这个随机字符串称为盐值,它的作用是增加哈希后密码的随机性。

加盐哈希的步骤大致如下图:

在用户注册阶段,系统根据用户输入的密码生成在数据库中的哈希密码值:

  • 系统首先随机生成一个足够长的随机字符串作为盐值,可以使用密码学安全的随机数生成算法;
  • 将盐值与用户输入的原始密码字符串拼接在一起(盐值放在密码的前后均可);
  • 对连接后的字符串计算哈希值,可以使用MD5、SHA-1、SHA256、SHA-512等哈希算法;由于也被证实MD5、SHA-1存在弱点,可以被碰撞攻击,建议至少使用SHA256算法;
  • 将盐值和哈希值一起存储在数据库中(可以向图中那样将hashed_password和salt通过:分隔符组合为一个字段后再存储在数据库中)。

验证登录时,系统根据用户名取出盐值,然后将用户输入的密码与盐值组合计算哈希值,与存储的原始哈希值比较,相同则验证成功。

在密码哈希前加入随机字符串(即“盐(salt)”)可以大幅增加了破解难度,同时不同用户如采用相同密码,也可以通过不同的盐在哈希后得到不同的哈希值,这可以有效地防止预计算表的攻击。

不过随着硬件算力的飞速提高,比如GPU、专用ASIC芯片以及云计算资源等,密码破解效率进一步提高,甚至普通人也可利用现成的破解工具和云资源进行密码破解,攻击者门槛大幅降低,简单加盐也已出现不能有效对抗硬件加速破解的情况。

于是人们开始考虑使用一些新哈希算法,这些算法可以大幅提高攻击者付出的时间和资源消耗成本,增加密码破解难度,这就是下面我们要说的慢哈希算法。

2.4 慢哈希算法阶段 – Argon2、Bcrypt、Scrypt和PBKDF2

Argon2BcryptScryptPBKDF2是目前主流的慢哈希算法,它们与SHA256等快速哈希算法的主要差异点如下:

  • 计算速度更慢,需要消耗更多CPU和内存资源,从而对抗硬件加速攻击;
  • 使用更复杂的算法,组合密码学原语,增加破解难度;
  • 可以配置资源消耗参数,调整安全强度;
  • 特定优化使并行计算困难;
  • 经过长时间的密码学分析,仍然安全可靠。

从这些特点可以知道:这些慢哈希算法更适合密码哈希的原因是可以大幅增加攻击者密码破解的成本,如果这么说大家印象还不够深刻,我们就来量化对比一下,下面是以SHA256和Scrypt两个算法为例做的一个简单的benchmark测试:

// web-app-password-storage/benchmark/benchmark_test.go

package main

import (
    "crypto/sha256"
    "testing"

    "golang.org/x/crypto/scrypt"
)

func BenchmarkSHA256(b *testing.B) {
    b.ReportAllocs()
    data := []byte("hello world")
    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        sha256.Sum256(data)
    }
}

func BenchmarkScrypt(b *testing.B) {
    b.ReportAllocs()
    const keyLen = 32
    data := []byte("hello world")
    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        scrypt.Key(data, data, 16384, 8, 1, keyLen)
    }
}

我们看看输出的benchmark结果是什么样的:

$go test -bench .
goos: darwin
goarch: amd64
pkg: demo
... ...
BenchmarkSHA256-8        6097324           195.3 ns/op         0 B/op          0 allocs/op
BenchmarkScrypt-8             26      41812138 ns/op    16781836 B/op         22 allocs/op
PASS
ok      demo    2.533s

我们看到无论是cpu消耗还是内存开销,Scrypt算法都是SHA256的几个数量级的倍数。

加盐的慢哈希也是目前的主流的用户密码存储方案,那有读者会问:这四个算法选择哪个更佳呢?说实话要想对这个四个算法做个全面的对比,需要很强的密码学专业知识,这里直接给结论(当然也是来自网络资料):建议使用Scrypt或Argon2系列的算法,它们俩可提供更高的抗ASIC和并行计算能力,Bcrypt由于简单高效和成熟,目前也仍十分流行。

不过,慢哈希算法在给攻击者带来时间和资源成本等困难的同时,也给服务端正常的身份认证带来一定的性能开销,不过大多数开发者认为这种设计取舍是值得的。

下面我们就基于慢哈希算法结合加盐,用实例说明一下一个Web应用的用户注册与登录过程中,密码是如何被存储和用来验证用户身份的。

3. 加盐哈希存储方案的示例

在这个示例中,我们建立两个html文件:一个是signup.html,用于模拟用户注册;一个是login.html,用于模拟用户登录:

// web-app-password-storage/signup.html

<!DOCTYPE html>
<html>
<head>
  <title>注册</title>
</head>
<body>

<form action="http://localhost:8080/signup" method="post">

  <label>用户名:</label>
  <input type="text" name="username"/>

  <label>密码:</label>
  <input type="password" name="password"/>

  <label>确认密码:</label>
  <input type="password" name="confirm-password"/>

  <button type="submit">注册</button>

</form>

</body>
</html>

// web-app-password-storage/login.html

<!DOCTYPE html>
<html>
<head>
  <title>登录</title>
</head>
<body>

<form action="http://localhost:8080/login" method="post">

  <label>用户名:</label>
  <input type="text" name="username"/>

  <label>密码:</label>
  <input type="password" name="password"/>

  <button type="submit">登录</button>

</form>

</body>
</html>

接下来,我们来写这个web应用的后端:一个http server:

// web-app-password-storage/server/main.go

package main

import (
    "database/sql"
    "encoding/base64"
    "math/rand"
    "net/http"
    "strings"
    "time"

    "golang.org/x/crypto/scrypt"
    _ "modernc.org/sqlite"
)

var db *sql.DB

func main() {
    // 连接SQLite数据库
    var err error
    db, err = sql.Open("sqlite", "./users.db")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    // 创建用户表
    sqltable := `
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            username TEXT,
            hashedpass TEXT
        );
    `
    _, err = db.Exec(sqltable)
    if err != nil {
        panic(err)
    }

    http.HandleFunc("/login", login)
    http.HandleFunc("/signup", signup)
    http.ListenAndServe(":8080", nil)
}

func signup(w http.ResponseWriter, r *http.Request) {
    username := r.FormValue("username")
    password := r.FormValue("password")
    cpassword := r.FormValue("confirm-password")

    if password != cpassword {
        http.Error(w, "password and confirmation password do not match", http.StatusBadRequest)
        return
    }

    // 注册新用户
    salt := generateSalt(16)
    hashedPassword := hashPassword(password, salt)
    stmt, err := db.Prepare("INSERT INTO users(username, hashedpass) values(?, ?)")
    if err != nil {
        panic(err)
    }
    _, err = stmt.Exec(username, hashedPassword+":"+salt)
    if err != nil {
        panic(err)
    }
    w.Write([]byte("signup ok!"))
}

func login(w http.ResponseWriter, r *http.Request) {
    username := r.FormValue("username")
    password := r.FormValue("password")

    // 验证登录
    storedHashedPassword, salt := getHashedPasswordForUser(db, username)
    hashedLoginPassword := hashPassword(password, salt)
    if hashedLoginPassword == storedHashedPassword {
        w.Write([]byte("Welcome!"))
    } else {
        http.Error(w, "Invalid username or password", http.StatusUnauthorized) // 401
    }
}

// 生成随机字符串作为盐值
func generateSalt(n int) string {
    rand.Seed(time.Now().UnixNano())
    letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
    b := make([]rune, n)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
    return string(b)
}

// 对密码进行bcrypt哈希并返回哈希值与随机盐值
func hashPassword(password, salt string) string {
    dk, err := scrypt.Key([]byte(password), []byte(salt), 1<<15, 8, 1, 32)
    if err != nil {
        panic(err)
    }
    return base64.StdEncoding.EncodeToString(dk)
}

// 从数据库获取用户哈希后的密码和盐值
func getHashedPasswordForUser(db *sql.DB, username string) (string, string) {
    var hashedPass string
    row := db.QueryRow("SELECT hashedpass FROM users WHERE username=?", username)
    if err := row.Scan(&hashedPass); err != nil {
        panic(err)
    }
    split := strings.Split(hashedPass, ":")
    return split[0], split[1]
}

示例的结构比较清晰,这里提供了两个http handler,一个是signup用于接收用户注册请求,一个是login,用于接收处理用户登录请求。在注册请求时,我们生成用户密码的带盐慢哈希值,与salt一起存入数据库,这里用sqlite代替通用关系型数据库;在login handler中,我们根据username读取数据库中的salt和hashed_password,然后基于请求中的password与salt重新做一遍hash,将得到的结果与数据库中读取的hashed_password比较,相同则说明用户输入的密码正确。

Go官方维护的golang.org/x/crypto为我们提供了高质量的scrypt包,当然crypto下也有bcrypt、argon2和pbkdf2的实现,感兴趣的童鞋可以自行研究。

4. 小结

用户密码的安全存储是保障Web应用与用户数据安全的基石。简单的密码存储实践如明文和弱哈希算法存在巨大隐患,而随着计算能力提升,任何weak password都可被轻松破解。为有效保护用户,Web应用必须采取更可靠的密码存储方案。

本文详细介绍了从简单明文、单向哈希到先进的加盐慢哈希的演进历程。我们看到,这是一场与不断增强的攻击手段进行的应对之争。随着硬件计算能力、并行与云计算等技术进步,必须加强密码存储机制的强度。当前,结合随机盐、迭代计算的慢哈希可大幅提高破解难度,是推荐的密码存储安全实践。

当然,密码安全需要持续关注新兴攻击手段,并及时采纳更强大的算法。这不仅是技术问题,也需要整个社区的共同努力,通过提高意识和最佳实践来保护用户。

本文示例所涉及的Go源码可以在这里下载。

5. 参考资料


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

聊聊Go与TLS 1.3

本文永久链接 – https://tonybai.com/2023/01/13/go-and-tls13

除了一些综述类文章和译文,我的文章选题多来源于实际工作和学习中遇到的问题。这次我们来聊聊近期遇到一个问题:如何加快基于TLS安全通信的海量连接的建连速度?

TLS(Transport Layer Security)传输安全层的下面是TCP层,我们首先可能会想到的是优化内核有关TCP握手的相关参数来快速建立TCP连接,比如:

  • net.ipv4.tcp_max_syn_backlog
  • net.ipv4.tcp_syncookies
  • net.ipv4.tcp_synack_retries
  • net.ipv4.tcp_abort_on_overflow
  • net.core.somaxconn
  • … …

关于Linux内核参数调优,大家可以参考一下极客时间专栏《系统性能调优必知必会》

此外为了加速海量连接的建连速度,提高应用从内核accept连接队列获取连接的速度,我们还可以采用多线程/多goroutine并发Listen同一个端口并并发Accept的机制,如果你使用的是Go语言,可以看看go-reuseport这个包。

说完TCP层,那么TLS层是否有可优化的、对建连速度有影响的地方呢?有的,那就是使用TLS 1.3版本来加速握手过程,从而加快建连速度。TLS 1.3是2018年发布的新TLS标准,近2-3年才开始得到主流语言、浏览器和web服务器的支持。那么它与之前的TLS 1.2有何不同呢?Go对TLS 1.3版本的支持程度如何?如何用Go编写使用TLS 1.3的安全通信代码?TLS 1.3建连速度究竟比TLS 1.2快多少呢?

带着这些问题,我们进入本篇正文部分!我们先来简要看看TLS 1.3与TLS 1.2版本的差异。

1. TLS 1.3与TLS 1.2的差异

TLS是由互联网工程任务组(Internet Engineering Task Force, IETF)制定和发布的、用于替代SSL的、基于加解密和签名算法的安全连接协议标准,其演进过程如下图:

其中TLS 1.0和1.1版本因不再安全,于2020年被作废,目前主流的版本,也是应用最为广泛的是2008年发布的TLS 1.2版本(使用占比如下图统计),而最新版本则是2018年正式发布的TLS 1.3,而TLS 1.3版本的发布也意味着TLS 1.2版本进入“作废期”,虽然实际中TLS 1.2的“下线”还需要很长时间:

TLS 1.3与TLS 1.2并不不兼容,在TLS 1.3协议规范中,我们能看到列出的TLS 1.3相对于TLS 1.2的一些主要改动:

  • 去除了原先对称加密算法列表中的非AEAD(Authenticated Encryption with Associated Data)算法,包括3DES、RC4、AES-CBC等,只支持更安全的加密算法。

注:常见的AEAD算法包括:AES-128-GCM、AES-256-GCM、ChaCha20-IETF-Poly1305等。在具备AES加速的CPU(桌面,服务器)上,建议使用AES-XXX-GCM系列,移动设备建议使用ChaCha20-IETF-Poly1305系列。

  • 静态RSA和Diffie-Hellman密码套件(cipher suites)已被删除;所有基于公钥的密钥交换机制现在都提供前向安全性。

注:前向安全(Forward Secrecy)是指的是长期使用的主密钥泄漏不会导致过去的会话密钥泄漏。前向安全能够保护过去进行的通讯不受密码或密钥在未来暴露的威胁。如果系统具有前向安全性,就可以保证在主密钥泄露时历史通讯的安全,即使系统遭到主动攻击也是如此。

  • TLS 1.2版本的协商机制已被废弃,引入了一个更快的新的密钥协商机制:PSK(Pre-Shared Key),简化了握手流程(下图是TLS 1.2与TLS 1.3握手流程的对比)。同时在ServerHello之后的所有握手信息现在都被加密了,以前在ServerHello中以明文方式发送的各种扩展信息现在也可以享受加密保护。

  • 增加了一个零往返时间(0-RTT)模式,在恢复连接建立时为一些应用数据节省了一个往返时间。但代价是丧失了某些安全属性。

注:当客户端(例如浏览器)首次成功完成与服务器的TLS 1.3握手后,客户端和服务器都可在本地存储预共享的加密密钥,这称为恢复主密钥。如果客户端稍后再次与服务器建立连接,则可以使用此恢复密钥将其第一条消息中的加密应用程序数据发送到服务器,而无需第二次执行握手。0-RTT模式有一个安全弱点。通过恢复模式发送数据不需要服务器的任何交互,这意味着攻击者(一般是中间人(middle-man))可以捕获加密的0-RTT数据,然后将其重新发送到服务器,或重放(Replay)它们。解决此问题的方法是确保所有0-RTT请求都是幂等的。

在这些主要变化中,与初次建连速度有关的显然是TLS 1.3握手机制的变化:从2-RTT缩短到1-RTT(如上图所示)。下面我们就用Go作为示例来看看TLS 1.3相对于TLS 1.2在建连速度方面究竟有怎样的提升。

2. Go对TLS 1.3的支持

  • Go语言从Go 1.12版本开始提供对TLS 1.3的可选支持。在Go 1.12版本下,你通过设置GODEBUG=tls13=1并且不显式设置tls Config的MaxVersion的情况下,便会开启TLS 1.3。这个版本实现中暂不支持TLS 1.3的0-RTT的特性。

  • Go 1.13版本默认情况下开启TLS 1.3,你可以使用GODEBUG=tls13=0关闭对TLS 1.3的支持。

  • 等到了Go 1.14版本,TLS 1.3成为默认TLS版本选项且无法再用GODEBUG=tls13=0关闭了!不过,通过Config.MaxVersion可以配置要使用的TLS版本。

  • Go 1.16版本中,在服务端或客户端不支持AES硬件加速的情况下,server端会优先选择其他AEAD的密码套件(cipher suite),比如ChaCha20Poly1305,而不会选择AES-GCM密码套件。

  • Go 1.18版本中,client端的Config.MinVersion将默认为TLS 1.2, 以替代原先的默认值TLS 1.0/TLS 1.1。不过你可以通过显式设置客户端的Config.MinVersion来改变这个设置。不过这个改动不影响server端。

了解了这些后,我们来看一个简单的使用Go和TLS 1.3版本的客户端与服务端示例。

3. Go TLS 1.3客户端与服务端通信示例

这次我们不去参考Go标准库crypto/tls包的样例,我们玩把时髦儿的:通过AI辅助生成一套基于TLS的client与server端的通信代码示例。ChatGPT不对大陆开放,我这里用的是AI编程助手(AICodeHelper),下面是生成过程的截图:

AICodeHelper为我们生成了大部分代码,但是server端代码有两个问题:只能处理一个client端连接和没有生成传入server证书和私钥的代码段,我们基于上面的框架代码做一下修改,得到我们的server和client端代码:

server端代码:

// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/server.go
package main

import (
    "bufio"
    "crypto/tls"
    "fmt"
    "net"
)

func main() {
    cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        fmt.Println(err)
        return
    }

    config := &tls.Config{Certificates: []tls.Certificate{cer}}
    ln, err := tls.Listen("tcp", "localhost:8443", config)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    r := bufio.NewReader(conn)
    for {
        msg, err := r.ReadString('\n')
        if err != nil {
            fmt.Println(err)
            return
        }

        println(msg)

        n, err := conn.Write([]byte("hello, world from server\n"))
        if err != nil {
            fmt.Println(n, err)
            return
        }
    }
}
// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/client.go

package main

import (
    "crypto/tls"
    "log"
)

func main() {
    conf := &tls.Config{
        InsecureSkipVerify: true,
    }

    conn, err := tls.Dial("tcp", "localhost:8443", conf)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    n, err := conn.Write([]byte("hello, world from client\n"))
    if err != nil {
        log.Println(n, err)
        return
    }

    buf := make([]byte, 100)
    n, err = conn.Read(buf)
    if err != nil {
        log.Println(n, err)
        return
    }

    println(string(buf[:n]))
}

为了方便期间,这里使用自签名证书,并且客户端不对服务端的公钥数字证书进行验签(我们无需生成创建CA的相关key和证书),我们只需要使用下面命令生成一对server.key和server.crt:

$openssl genrsa -out server.key 2048
Generating RSA private key, 2048 bit long modulus
..........................+++
................................+++
e is 65537 (0x10001)

$openssl req -new -x509 -sha256 -key server.key -out server.crt -days 3650
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) []:
State or Province Name (full name) []:
Locality Name (eg, city) []:
Organization Name (eg, company) []:
Organizational Unit Name (eg, section) []:
Common Name (eg, fully qualified host name) []:localhost
Email Address []:

关于非对称加密和数字证书方面的详细内容,可以参见我的《Go语言精进之路》一书的第51条“使用net/http包实现安全通信”

运行Server和Client,这里我使用的是Go 1.19版本编译器:

$go run server.go
hello, world from client

EOF

$go run client.go
hello, world from server

我们的示例已经可以正常运行了!那么如何证明示例中的client与server间使用的是1.3版本的TLS连接呢?或者如何查看client与server间使用的是哪个TLS版本呢?

有小伙伴可能会说:用wireshark抓包看,这个可行,但是用wireshark抓tls包,尤其是1.3建连包比较费劲。我们有更简单的方式,我们在开发环境可以通过修改标准库来实现。我们继续往下看。

4. server和client端的TLS版本的选择

TLS握手过程由client端发起,从client的视角,当client收到serverHello的响应后便可得到决策后要使用的TLS版本。因此这里我们改造一下crypto/tls/handshake_client.go的clientHandshake方法,在其实现中利用fmt.Printf输出TLS连接相关的信息即可(见下面代码中”====”开头的输出内容):

// $GOROOT/src/crypto/tls/handshake_client.go

func (c *Conn) clientHandshake(ctx context.Context) (err error) {
    ... ...
    hello, ecdheParams, err := c.makeClientHello()
    if err != nil {
        return err
    }
    c.serverName = hello.serverName

    fmt.Printf("====client: supportedVersions: %x, cipherSuites: %x\n", hello.supportedVersions, hello.cipherSuites)

    ... ...

    msg, err := c.readHandshake()
    if err != nil {
        return err
    }

    serverHello, ok := msg.(*serverHelloMsg)
    if !ok {
        c.sendAlert(alertUnexpectedMessage)
        return unexpectedMessageError(serverHello, msg)
    }

    if err := c.pickTLSVersion(serverHello); err != nil {
        return err
    }

    ... ...

    if c.vers == VersionTLS13 {
        fmt.Printf("====client: choose tls 1.3, server use ciphersuite: [0x%x]\n", serverHello.cipherSuite)
        ... ...
        // In TLS 1.3, session tickets are delivered after the handshake.
        return hs.handshake()
    }
    fmt.Printf("====client: choose tls 1.2, server use ciphersuite: [0x%x]\n", serverHello.cipherSuite)

    hs := &clientHandshakeState{
        ... ...
    }

    if err := hs.handshake(); err != nil {
        return err
    }
    ... ...
}

修改完标准库后,我们再来重新运行一下上面的client.go:

$go run client.go
====client: supportedVersions: [304 303], cipherSuites: [c02b c02f c02c c030 cca9 cca8 c009 c013 c00a c014 9c 9d 2f 35 c012 a 1301 1302 1303]
====client: choose tls 1.3, server use ciphersuite: [0x1301]
hello, world from server

这里我们看一下第一行输出的内容,这里输出的是client端构建clientHello握手包中的内容,展示的是client端支持的TLS版本以及密码套件(cipher suites),我们看到客户端支持0×304、0×303两个TLS版本,这两个数字与下面代码中的常量分别对应:

// $GOROOT/src/crypto/tls/common.go
const (
    VersionTLS10 = 0x0301
    VersionTLS11 = 0x0302
    VersionTLS12 = 0x0303
    VersionTLS13 = 0x0304

    // Deprecated: SSLv3 is cryptographically broken, and is no longer
    // supported by this package. See golang.org/issue/32716.
    VersionSSL30 = 0x0300
)

而输出的cipherSuites中包含的那些十六进制数则来自下面常量:

// $GOROOT/src/crypto/tls/cipher_suites.go
const (
    // TLS 1.0 - 1.2 cipher suites.
    TLS_RSA_WITH_RC4_128_SHA                      uint16 = 0x0005
    TLS_RSA_WITH_3DES_EDE_CBC_SHA                 uint16 = 0x000a
    TLS_RSA_WITH_AES_128_CBC_SHA                  uint16 = 0x002f
    TLS_RSA_WITH_AES_256_CBC_SHA                  uint16 = 0x0035
    TLS_RSA_WITH_AES_128_CBC_SHA256               uint16 = 0x003c
    TLS_RSA_WITH_AES_128_GCM_SHA256               uint16 = 0x009c
    TLS_RSA_WITH_AES_256_GCM_SHA384               uint16 = 0x009d
    TLS_ECDHE_ECDSA_WITH_RC4_128_SHA              uint16 = 0xc007
    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA          uint16 = 0xc009
    TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA          uint16 = 0xc00a
    TLS_ECDHE_RSA_WITH_RC4_128_SHA                uint16 = 0xc011
    TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA           uint16 = 0xc012
    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA            uint16 = 0xc013
    TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA            uint16 = 0xc014
    TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256       uint16 = 0xc023
    TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256         uint16 = 0xc027
    TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256         uint16 = 0xc02f
    TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256       uint16 = 0xc02b
    TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384         uint16 = 0xc030
    TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384       uint16 = 0xc02c
    TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256   uint16 = 0xcca8
    TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xcca9

    // TLS 1.3 cipher suites.
    TLS_AES_128_GCM_SHA256       uint16 = 0x1301
    TLS_AES_256_GCM_SHA384       uint16 = 0x1302
    TLS_CHACHA20_POLY1305_SHA256 uint16 = 0x1303
    ... ...
}

而从client.go运行结果中的第二行输出可以看出:这次建连,双方最终选择了TLS 1.3版本和TLS_AES_128_GCM_SHA256这个cipher suite。这与前面我们在回顾Go语言对TLS 1.3的支持历史中的描述一致,TLS 1.3是建连版本的默认选择。

那么我们是否可以选择建连时使用的版本呢?当然可以,我们既可以在server端配置,也可以在客户端配置。我们先来看看在Server端如何配置:

// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/server_tls12.go

func main() {
    cer, err := tls.LoadX509KeyPair("server.crt", "server.key")
    if err != nil {
        fmt.Println(err)
        return
    }

    config := &tls.Config{
        Certificates: []tls.Certificate{cer},
        MaxVersion:   tls.VersionTLS12,
    }
    ... ...
}

我们基于server.go创建了server_tls12.go,在这个新源文件中,我们在tls.Config中增加一个配置MaxVersion,并将其值设置为tls.VersionTLS12,其含义是其最高支持的TLS版本为TLS 1.2。这样当我们使用client.go与基于server_tls12.go运行的服务端程序建连时,我们将得到下面输出:

$go run client.go
====client: supportedVersions: [304 303], cipherSuites: [c02b c02f c02c c030 cca9 cca8 c009 c013 c00a c014 9c 9d 2f 35 c012 a 1301 1302 1303]
====client: choose tls 1.2, server use ciphersuite: [0xc02f]
hello, world from server

我们看到,交互的双方最后选择了TLS 1.2版本,使用的密码套件为0xc02f,即TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256。

同理,如果你想在client端配置最高支持TLS 1.2版本的话,也可以采用同样的方式,大家可以看看本文对应代码库中的client_tls12.go这个源文件,这里就不赘述了。

到这里,一些小伙伴可能有了一个疑问:我们可以配置使用的TLS的版本,那么对于TLS 1.3而言,我们是否可以配置要使用的密码套件呢?答案是目前不可以,理由来自于Config.CipherSuites字段的注释:“Note that TLS 1.3 ciphersuites are not configurable”:

// $GOROOT/src/crypto/tls/common.go

type Config struct {
    ... ...
    // CipherSuites is a list of enabled TLS 1.0–1.2 cipher suites. The order of
    // the list is ignored. Note that TLS 1.3 ciphersuites are not configurable.
    //
    // If CipherSuites is nil, a safe default list is used. The default cipher
    // suites might change over time.
    CipherSuites []uint16
    ... ...
}

tls包会根据系统是否支持AES加速来选择密码套件,如果支持AES加速,就使用下面的defaultCipherSuitesTLS13,这样AES相关套件会被优先选择,否则defaultCipherSuitesTLS13NoAES会被使用,TLS_CHACHA20_POLY1305_SHA256会被优先选择:

// $GOROOT/src/crypto/tls/cipher_suites.go

// defaultCipherSuitesTLS13 is also the preference order, since there are no
// disabled by default TLS 1.3 cipher suites. The same AES vs ChaCha20 logic as
// cipherSuitesPreferenceOrder applies.
var defaultCipherSuitesTLS13 = []uint16{
    TLS_AES_128_GCM_SHA256,
    TLS_AES_256_GCM_SHA384,
    TLS_CHACHA20_POLY1305_SHA256,
}   

var defaultCipherSuitesTLS13NoAES = []uint16{
    TLS_CHACHA20_POLY1305_SHA256,
    TLS_AES_128_GCM_SHA256,
    TLS_AES_256_GCM_SHA384,
}

注:joe shaw曾写过一篇文章“Abusing go:linkname to customize TLS 1.3 cipher suites”,文中描述了一种通过go:linkname定制TLS 1.3密码套件的方法,有兴趣的小伙伴们可以去阅读一下。

5. 建连速度benchmark

最后我们再来看看相较于TLS 1.2,TLS 1.3的建连速度究竟快了多少。考虑到两个版本在RTT数量上的差异,即网络延迟对建连速度影响较大,我特意选择了一个ping在20-30ms的网络。我们为TLS 1.2和TLS 1.3分别建立Benchmark Test:

// https://github.com/bigwhite/experiments/blob/master/go-and-tls13/benchmark/benchmark_test.go

package main

import (
    "crypto/tls"
    "testing"
)

func tls12_dial() error {
    conf := &tls.Config{
        InsecureSkipVerify: true,
        MaxVersion:         tls.VersionTLS12,
    }

    conn, err := tls.Dial("tcp", "192.168.11.10:8443", conf)
    if err != nil {
        return err
    }
    conn.Close()
    return nil
}

func tls13_dial() error {
    conf := &tls.Config{
        InsecureSkipVerify: true,
    }

    conn, err := tls.Dial("tcp", "192.168.11.10:8443", conf)
    if err != nil {
        return err
    }
    conn.Close()
    return nil
}

func BenchmarkTls13(b *testing.B) {
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        err := tls13_dial()
        if err != nil {
            panic(err)
        }
    }
}

func BenchmarkTls12(b *testing.B) {
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        err := tls12_dial()
        if err != nil {
            panic(err)
        }
    }
}

server部署在192.168.11.10上,针对每个benchmark test,我们给予10s钟的测试时间,下面是运行结果:

$go test -benchtime 10s -bench .
goos: linux
goarch: amd64
pkg: demo
cpu: Intel(R) Core(TM) i7-9700 CPU @ 3.00GHz
BenchmarkTls13-8        216   56036809 ns/op   47966 B/op     608 allocs/op
BenchmarkTls12-8        145   82395933 ns/op   26655 B/op     283 allocs/op
PASS
ok  demo 37.959s

我们看到相对与TLS 1.2,TLS 1.3建连速度的确更快些。不过从内存分配的情况来看,Go TLS 1.3的实现似乎更复杂一些。

6. 参考资料

  • RFC 8446:The Transport Layer Security (TLS) Protocol Version 1.3 – https://datatracker.ietf.org/doc/rfc8446/
  • 前向安全 – https://sunhuachuang.gitbooks.io/sun-note/content/cryptography/forward_backward_secrecy.html

本文涉及的源码可以在这里下载。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats