File size: 6,636 Bytes
e48a2d8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 | package auth
import (
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
)
// testdata/wbencrypted-auth.json 是**合成**向量:用 wbencrypted.go 里记录的
// at-rest 密钥 + 文档化的 AAD 拼接口径加密而成(生成脚本走的是 DistPub/workbuddy2api
// 的同一套参数),不是任何真实账号的凭据。三个字段刻意覆盖三种明文形态:
// 纯文本 token、Buffer 包装的昵称、数字型的 expiresAt。
const wbVectorPath = "testdata/wbencrypted-auth.json"
func TestParseWBEncryptedAuthFile(t *testing.T) {
raw, err := os.ReadFile(wbVectorPath)
if err != nil {
t.Fatalf("读向量失败: %v", err)
}
a, err := Parse(raw)
if err != nil {
t.Fatalf("解析加密 auth 文件失败: %v", err)
}
for _, c := range []struct{ name, got, want string }{
{"accessToken", a.AccessToken, "at-from-wbencrypted"},
{"refreshToken", a.RefreshToken, "rt-from-wbencrypted"},
{"nickname", a.Nickname, "小凛"},
{"uid", a.UID, "uid-wb-1"},
{"deviceToken", a.DeviceToken, "v3:test-device-token"},
{"realm", a.Realm(), "cn"},
} {
if c.got != c.want {
t.Errorf("%s = %q want %q", c.name, c.got, c.want)
}
}
// expiresAt 在文件里是毫秒,Parse 后必须归一成秒。
if a.ExpiresAt != 1800000000 {
t.Errorf("expiresAt = %d want 1800000000(毫秒应归一为秒)", a.ExpiresAt)
}
}
// AAD 是最容易错一个字节的地方:这里对着参考实现的字节串逐位校验。
func TestWBFieldAADMatchesReference(t *testing.T) {
const want = "57422d41414400010000000557424556310000000673796d2d763100000001" +
"0000001039313237646561316234343032306137020000"
got := hex.EncodeToString(wbFieldAAD(1, wbKeyID(sha256.Sum256([]byte(wbAtRestSecretKey)))))
if got != want {
t.Fatalf("AAD 与参考实现不一致:\n got %s\nwant %s", got, want)
}
}
// 桌面端换过 at-rest 密钥时必须报错而不是解出乱码当 token 用。
func TestParseWBEncryptedKeyIDMismatchFails(t *testing.T) {
raw, err := os.ReadFile(wbVectorPath)
if err != nil {
t.Fatalf("读向量失败: %v", err)
}
var doc map[string]any
if err := json.Unmarshal(raw, &doc); err != nil {
t.Fatalf("向量不是合法 JSON: %v", err)
}
authObj := doc["auth"].(map[string]any)
env := authObj["accessToken"].(map[string]any)
// 换掉 envelope 里的 keyId(解 base64 再改再编回)。
rawEnv, err := base64.StdEncoding.DecodeString(env["envelope"].(string))
if err != nil {
t.Fatalf("信封不是合法 base64: %v", err)
}
keyID := wbKeyID(sha256.Sum256([]byte(wbAtRestSecretKey)))
plainEnv := strings.Replace(string(rawEnv), keyID, "0000000000000000", 1)
if plainEnv == string(rawEnv) {
t.Fatal("向量里找不到 keyId,测试自身失效")
}
env["envelope"] = base64.StdEncoding.EncodeToString([]byte(plainEnv))
bad, _ := json.Marshal(doc)
if _, err := Parse(bad); err == nil {
t.Fatal("keyId 不匹配时应当报错")
} else if !strings.Contains(err.Error(), "at_rest_key_mismatch") {
t.Fatalf("错误应说明是密钥不匹配,实际: %v", err)
}
}
// 刷新后的写回:来源是加密文件,就只能回写加密形态——明文覆盖桌面端文件是把
// 别人的登录态写成我们能读、桌面端读不了的样子。
func TestSaveAtomicKeepsEnvelopeForEncryptedSource(t *testing.T) {
raw, err := os.ReadFile(wbVectorPath)
if err != nil {
t.Fatalf("读向量失败: %v", err)
}
path := filepath.Join(t.TempDir(), "auth.info")
if err := os.WriteFile(path, raw, 0o600); err != nil {
t.Fatalf("写临时 auth 失败: %v", err)
}
a, err := Parse(raw)
if err != nil {
t.Fatalf("解析失败: %v", err)
}
a.FilePath = path
a.AccessToken = "at-refreshed"
a.RefreshToken = "rt-refreshed"
if err := a.SaveAtomic(); err != nil {
t.Fatalf("写回失败: %v", err)
}
saved, err := os.ReadFile(path)
if err != nil {
t.Fatalf("读回失败: %v", err)
}
if strings.Contains(string(saved), "at-refreshed") || strings.Contains(string(saved), "rt-refreshed") {
t.Fatal("写回文件里出现了明文 token")
}
if !strings.Contains(string(saved), `"$wbEncrypted"`) {
t.Fatal("写回文件丢了信封形态")
}
again, err := Parse(saved)
if err != nil {
t.Fatalf("回写后再解析失败: %v", err)
}
if again.AccessToken != "at-refreshed" || again.RefreshToken != "rt-refreshed" {
t.Fatalf("回写后的 token 读不回来: %+v", again)
}
if again.Nickname != "小凛" {
t.Fatalf("回写后的昵称读不回来: %q", again.Nickname)
}
}
// 客户端不加密的字段,回写也必须留明文。
//
// 实测客户端的信封清单是 accessToken / refreshToken / nickname / phoneNumber,
// expiresAt 明文。按固定清单去封会把它读作明文的 expiresAt 加密,桌面端就读不回来。
func TestSaveAtomicLeavesPlainFieldsPlain(t *testing.T) {
raw, err := os.ReadFile(wbVectorPath)
if err != nil {
t.Fatalf("读向量失败: %v", err)
}
var doc map[string]any
if err := json.Unmarshal(raw, &doc); err != nil {
t.Fatalf("向量不是合法 JSON: %v", err)
}
doc["auth"].(map[string]any)["expiresAt"] = float64(1800000000000) // 还原成明文数字
raw, _ = json.Marshal(doc)
path := filepath.Join(t.TempDir(), "auth.info")
if err := os.WriteFile(path, raw, 0o600); err != nil {
t.Fatalf("写临时 auth 失败: %v", err)
}
a, err := Parse(raw)
if err != nil {
t.Fatalf("解析失败: %v", err)
}
a.FilePath = path
if err := a.SaveAtomic(); err != nil {
t.Fatalf("写回失败: %v", err)
}
saved, _ := os.ReadFile(path)
var back map[string]any
if err := json.Unmarshal(saved, &back); err != nil {
t.Fatalf("写回文件不是合法 JSON: %v", err)
}
if _, isEnvelope := back["auth"].(map[string]any)["expiresAt"].(map[string]any); isEnvelope {
t.Error("expiresAt 原本明文,回写不该加密")
}
if _, isEnvelope := back["auth"].(map[string]any)["accessToken"].(map[string]any); !isEnvelope {
t.Error("accessToken 原本加密,回写必须仍是信封")
}
if again, err := Parse(saved); err != nil || again.ExpiresAt != 1800000000 {
t.Errorf("回写后再解析失败或到期时间不对: %v %+v", err, again)
}
}
// 未加密文件必须原样走老路径(零回归)。
func TestParseUnencryptedStillWorks(t *testing.T) {
a, err := Parse([]byte(`{"auth":{"accessToken":"at","refreshToken":"rt","realm":"global"},"account":{"uid":"u1"}}`))
if err != nil {
t.Fatalf("明文 auth 解析失败: %v", err)
}
if a.AccessToken != "at" || a.UID != "u1" || a.Realm() != "global" {
t.Fatalf("明文解析结果不对: %+v", a)
}
}
|