标签 解密 下的文章

通过实例理解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

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

使用Golang开发微信公众平台-接收加密消息

在上一篇“接收文本消息”一文中,我们了解到:公众服务与微信服务器间的消息是“裸奔”的(即明文传输,通过抓包可以看到)。显然这对于一些对安 全性要求较高的大企业服务号来说,比如银行、证券、电信运营商或航空客服等是不能完全满足要求的。于是乎就有了微信服务器与公众服务间的数据加密 通信流程。

公众号管理员可以在公众号“开发者中心”选择是否采用"安全模式"(区别于明文模式):

一旦选择了“安全模式”,微信服务器在向公众号服务转发消息时会对XML数据包部分内容进行加密处理。这类加密后的请求Body中的XML数据变 成了下面这样:

xml数据基本结构变成了:

<xml>
    <ToUserName>xx</ToUserName>
    <Encrypt>xx</Encrypt>
</xml>

另外在“安全模式”下,Http Post Request line中也增加了两个字段:encrypt_typemsg_signuature,用于消息类型判断以及加密消息内容有效性校验:

POST /?signature=891789ec400309a6be74ac278030e472f90782a5&timestamp=1419214101&nonce=788148964&encrypt_type=aes&msg_signature=87d7b127fab3771b452bc6a592f530cd8edba950 HTTP/1.1\r\n

其中:

encrypt_type = "aes",说明是加密消息,否则为"raw”,即未加密消息。
msg_signature=sha1(sort(Token, timestamp, nonce, msg_encrypt))

对于测试号,测试号配置页面没有加密相关配置,因此只能通过“微信公众平台接口调试工具”来进行相关加密接口调试。

一、消息签名验证

对于“安全模式”下的消息交互,首先要做的就是消息签名验证,只有通过验证的消息才会进行下一步解密、解析和处理。

消息签名验证的原理是比较微信平台HTTP Post Line中携带的msg_signature与通过Token、timestamp、nonce和msg_encrypt等四个字段值计算出的 msg_signture是否一致,一致则通过消息签名验证。

我们依旧在procRequest中完成对“安全模式”下消息的签名验证。

//recvencryptedtextmsg.go
type EncryptRequestBody struct {
        XMLName    xml.Name `xml:"xml"`
        ToUserName string
        Encrypt    string
}

func makeMsgSignature(timestamp, nonce, msg_encrypt string) string {
        sl := []string{token, timestamp, nonce, msg_encrypt}
        sort.Strings(sl)
        s := sha1.New()
        io.WriteString(s, strings.Join(sl, ""))
        return fmt.Sprintf("%x", s.Sum(nil))
}

func validateMsg(timestamp, nonce, msgEncrypt, msgSignatureIn string) bool {
        msgSignatureGen := makeMsgSignature(timestamp, nonce, msgEncrypt)
        if msgSignatureGen != msgSignatureIn {
                return false
        }
        return true
}

func parseEncryptRequestBody(r *http.Request) *EncryptRequestBody {
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
                log.Fatal(err)
                return nil
        }
        requestBody := &EncryptRequestBody{}
        xml.Unmarshal(body, requestBody)
        return requestBody
}

func procRequest(w http.ResponseWriter, r *http.Request) {
        r.ParseForm()

        timestamp := strings.Join(r.Form["timestamp"], "")
        nonce := strings.Join(r.Form["nonce"], "")
        signature := strings.Join(r.Form["signature"], "")
        encryptType := strings.Join(r.Form["encrypt_type"], "")
        msgSignature := strings.Join(r.Form["msg_signature"], "")

        … …

        f r.Method == "POST" {
                if encryptType == "aes" {
                        log.Println("Wechat Service: in safe mode")
                        encryptRequestBody := parseEncryptRequestBody(r)
                       
                        //Validate msg signature
                        if !validateMsg(timestamp, nonce, encryptRequestBody.Encrypt, msgSignature) {
                                log.Println("Wechat Service: msg_signature is invalid")
                                return
                        }
                        log.Println("Wechat Service: msg_signature validation is ok!")
                … …
        }
        … …
}

程序编译执行结果如下:
$sudo ./recvencryptedtextmsg
2014/12/22 13:15:56 Wechat Service: Start!

用手机微信发送一条消息给公众号,程序输出如下结果:

2014/12/22 13:17:35 Wechat Service: in safe mode
2014/12/22 13:17:35 Wechat Service: msg_signature validation is ok!

二、数据包解密

到目前为止,我们已经得到了经过消息验证ok的加密数据包EncryptRequestBody 的Encrypt。要想得到真正的消息内容,我们需要对Encrypt字段的值进行解密处理。微信采用的是AES加解密方案, 下面我们就来看看如何做AES解密。

在开发者中心选择转换为“安全模式”时,有一个字段EncodingAESKey需要填写,这个字段固定为43个字符,它就是我们在运用AES算 法时需要的那个Key。不过这个EncodingAESKey是被编了码的,真正用来加解密的AESKey需要我们自己通过解码得到。解码方法 为:

AESKey=Base64_Decode(EncodingAESKey + “=”)

Base64 decode后,我们就得到了一个32个字节的AESKey,可以看出微信加密解密用的是AES-256算法(256=32x8bit)。

在Golang中,我们可以通过下面代码得到真正的AESKey:

const (
        token = "wechat4go"
        appID = "wx5b5c2614d269ddb2"
        encodingAESKey = "kZvGYbDKbtPbhv4LBWOcdsp5VktA3xe9epVhINevtGg"
)

var aesKey []byte

func encodingAESKey2AESKey(encodingKey string) []byte {
        data, _ := base64.StdEncoding.DecodeString(encodingKey + "=")
        return data
}

func init() {
        aesKey = encodingAESKey2AESKey(encodingAESKey)
}

有了AESKey,我们再来解密数据包。微信公众平台开发文档给出了加密数据包的解析步骤:

1. aes_msg=Base64_Decode(msg_encrypt)
2. rand_msg=AES_Decrypt(aes_msg)
3. 验证尾部$AppId是否是自己的AppId,相同则表示消息没有被篡改,这里进一步加强了消息签名验证
4. 去掉rand_msg头部的16个随机字节,4个字节的msg_len和尾部的$AppId即为最终的xml消息体

微信Wiki中如果能用一个简单的图来说明Base64_Decode后的数据格式就更好了。这里进一步说明一下,解密后的数据,我们称之 plainData,它由四部分组成,按先后顺序排列分别是:

1、随机值       16字节
2、xml包长度    4字节 (注意以BIG_ENDIAN方式读取)
3、xml包  (*这部分数据的长度由上一个字段标识,这个包等价于一个完整的文本接收消息体数据,从ToUsername到MsgID都 有)
4、appID

其中第三段xml包是一个完整的接收文本数据包,与“接收消息”一文中的标准文本数据包格式一致,这就方便我们解析了。好了,下面用代码阐述解 密、解析过程以及appid验证:

procRequest中,增加如下代码:

// Decode base64
cipherData, err := base64.StdEncoding.DecodeString(encryptRequestBody.Encrypt)
if err != nil {
        log.Println("Wechat Service: Decode base64 error:", err)
        return
}

// AES Decrypt
plainData, err := aesDecrypt(cipherData, aesKey)
if err != nil {
        fmt.Println(err)
        return
}

//Xml decoding
textRequestBody, _ := parseEncryptTextRequestBody(plainData)
fmt.Printf("Wechat Service: Recv text msg [%s] from user [%s]!",
            textRequestBody.Content,
            textRequestBody.FromUserName)

根据解密方法,我们先对encryptRequestBody.Encrypt进行base64 decode操作得到cipherData,再用aesDecrypt对cipherData进行解密得到上面提到的由四部分组成的plainData。plainData经过xml decoding后就得到我们的TextRequestBody struct。

这里难点显然在aesDecrypt的实现上了。微信的加密包采用aes-256算法,秘钥长度32B,采用PKCS#7 Padding方式。Golang提供了强大的AES加密解密方法,我们利用这些方法实现微信包的解密:

func aesDecrypt(cipherData []byte, aesKey []byte) ([]byte, error) {
        k := len(aesKey) //PKCS#7
        if len(cipherData)%k != 0 {
                return nil, errors.New("crypto/cipher: ciphertext size is not multiple of aes key length")
        }

        block, err := aes.NewCipher(aesKey)
        if err != nil {
                return nil, err
        }

        iv := make([]byte, aes.BlockSize)
        if _, err := io.ReadFull(rand.Reader, iv); err != nil {
                return nil, err
        }

        blockMode := cipher.NewCBCDecrypter(block, iv)
        plainData := make([]byte, len(cipherData))
        blockMode.CryptBlocks(plainData, cipherData)
        return plainData, nil
}

对于解密后的plainData做appID校验以及xml Decoding处理如下:

func parseEncryptTextRequestBody(plainText []byte) (*TextRequestBody, error) {
        fmt.Println(string(plainText))

        // Read length
        buf := bytes.NewBuffer(plainText[16:20])
        var length int32
        binary.Read(buf, binary.BigEndian, &length)
        fmt.Println(string(plainText[20 : 20+length]))

        // appID validation
        appIDstart := 20 + length
        id := plainText[appIDstart : int(appIDstart)+len(appID)]
        if !validateAppId(id) {
                log.Println("Wechat Service: appid is invalid!")
                return nil, errors.New("Appid is invalid")
        }
        log.Println("Wechat Service: appid validation is ok!")

        // xml Decoding
        textRequestBody := &TextRequestBody{}
        xml.Unmarshal(plainText[20:20+length], textRequestBody)
        return textRequestBody, nil
}

编译执行输出textRequestBody:

&{{ xml} gh_6ebaca4bb551 on95ht9uPITsmZmq_mvuz4h6f6CI 1.419239875s text Hello, Wechat 6095588848508047134}

三、响应消息的数据包加密

微信公众平台开发文档要求:公众账号对密文消息的回复也要求加密。

对比一下普通的响应消息格式和加密后的响应消息格式:

加密后:

我们定义一个结构体映射响应消息数据包:

type EncryptResponseBody struct {
        XMLName      xml.Name `xml:"xml"`
        Encrypt      CDATAText
        MsgSignature CDATAText
        TimeStamp    string
        Nonce        CDATAText
}

type CDATAText struct {
        Text string `xml:",innerxml"`
}

我们要做的就是给EncryptResponseBody的实例逐一赋值,然后通过xml.MarshalIndent转成xml数据流即可,各字 段值生成规则如下:

Encrypt = Base64_Encode(AES_Encrypt [random(16B)+ msg_len(4B) + msg + $AppId])
MsgSignature=sha1(sort(Token, timestamp, nonce, msg_encrypt))
TimeStamp = 用请求中的值或新生成
Nonce = 用请求中的值或新生成

微信公众接口的加密复杂度要比解密高一些,关键问题在于加密结果的判定和加密逻辑的调试,AES加密出的结果每次都不同,我们要么通过微信平台真实操作验证,要么通过微信提供的在线调试工具验证加密是否正确。这里强烈建议使用在线调试工具(测试号只能选择这一种)。

在线调试工具的配置参考如下,ToUserName和FromUserName建议填写真实的(通过解密Post包打印输出得到):

如果在线调试工具收到你的应答,并解密成功,会给出如下反馈:

在procRequest中,我们在接收解析完Http Request后,通过下面几行代码构造一个加密的Response返回给微信平台或调试工具:

responseEncryptTextBody, _ := makeEncryptResponseBody(textRequestBody.ToUserName,
                                textRequestBody.FromUserName,
                                "Hello, "+textRequestBody.FromUserName,
                                nonce,
                                timestamp)
w.Header().Set("Content-Type", "text/xml")
fmt.Fprintf(w, string(responseEncryptTextBody))

func makeEncryptResponseBody(fromUserName, toUserName, content, nonce, timestamp string) ([]byte, error) {
        encryptBody := &EncryptResponseBody{}

        encryptXmlData, _ := makeEncryptXmlData(fromUserName, toUserName, timestamp, content)
        encryptBody.Encrypt = value2CDATA(encryptXmlData)
        encryptBody.MsgSignature = value2CDATA(makeMsgSignature(timestamp, nonce, encryptXmlData))
        encryptBody.TimeStamp = timestamp
        encryptBody.Nonce = value2CDATA(nonce)

        return xml.MarshalIndent(encryptBody, " ", "  ")
}

应答Xml包中只有Encrypt字段是加密的,该字段的生成方式如下:

func makeEncryptXmlData(fromUserName, toUserName, timestamp, content string) (string, error) {
        // Encrypt part3: Xml Encoding
        textResponseBody := &TextResponseBody{}
        textResponseBody.FromUserName = value2CDATA(fromUserName)
        textResponseBody.ToUserName = value2CDATA(toUserName)
        textResponseBody.MsgType = value2CDATA("text")
        textResponseBody.Content = value2CDATA(content)
        textResponseBody.CreateTime = timestamp
        body, err := xml.MarshalIndent(textResponseBody, " ", "  ")
        if err != nil {
                return "", errors.New("xml marshal error")
        }

        // Encrypt part2: Length bytes
        buf := new(bytes.Buffer)
        err = binary.Write(buf, binary.BigEndian, int32(len(body)))
        if err != nil {
                fmt.Println("Binary write err:", err)
        }
        bodyLength := buf.Bytes()

        // Encrypt part1: Random bytes
        randomBytes := []byte("abcdefghijklmnop")

        // Encrypt Part, with part4 - appID
        plainData := bytes.Join([][]byte{randomBytes, bodyLength, body, []byte(appID)}, nil)
        cipherData, err := aesEncrypt(plainData, aesKey)
        if err != nil {
                return "", errors.New("aesEncrypt error")
        }

        return base64.StdEncoding.EncodeToString(cipherData), nil
}

func aesEncrypt(plainData []byte, aesKey []byte) ([]byte, error) {
        k := len(aesKey)
        if len(plainData)%k != 0 {
                plainData = PKCS7Pad(plainData, k)
        }
       
        block, err := aes.NewCipher(aesKey)
        if err != nil {
                return nil, err
        }

        iv := make([]byte, aes.BlockSize)
        if _, err := io.ReadFull(rand.Reader, iv); err != nil {
                return nil, err
        }

        cipherData := make([]byte, len(plainData))
        blockMode := cipher.NewCBCEncrypter(block, iv)
        blockMode.CryptBlocks(cipherData, plainData)

        return cipherData, nil
}

根据官方文档: 微信所用的AES采用的时CBC模式,秘钥长度为32个字节(aesKey),数据采用PKCS#7填充;PKCS#7:K为秘钥字节数(采用32),buf为待加密的内容,N为其字节数。Buf需要被填充为K的整数倍。因此我们pad要加密的数据时,务必pad为k(=32)的整数倍,而不是aes.BlockSize(=16)的整数倍。

采用安全模式后的公众号消息交互性能似乎下降了,发送"hello, wechat"给公众号后好长时间才收到响应。

微信公众号接收加密消息的代码在这里可以下载。这些代码只是演示代码,结构上绝不算优化,大家可以将这些代码封装成通用的接口为后续微信公众平台接口开发奠定基础。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! 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