File size: 10,463 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
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
// wbencrypted.go 解密新版桌面端 auth 文件里的 $wbEncrypted 字段。
//
// 逆向来源:DistPub/workbuddy2api 的 wb_auth_decrypt.js + converter.py
// (对 WorkBuddy.app 逆向得到)。新版桌面端把 auth 文件里 accessToken /
// refreshToken / expiresAt / nickname 等字段换成信封加密:
//
//	{"$wbEncrypted":1,"envelope":"<base64(JSON{suite,keyId,nonce,authTag,ciphertext})>"}
//
// key = sha256(utf8(atRestSecretKey 字符串本身)),AES-256-GCM;
// keyId = sha256(key) 的 hex 前 16 位,用于校验信封是否由同一把密钥产生;
// AAD 是固定二进制拼接(见 wbFieldAAD)。密钥来自 Electron 原生绑定
// electron_browser_workbuddy_storage 的 loggerGet(),随版本可能变——keyId
// 对不上时报错,不猜。无 $wbEncrypted 字段的文件原样返回,零成本。
package auth

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"strings"
)

// wbAtRestSecretKey 桌面端 at-rest 静态密钥(canonical base64,44 位)。
// 桌面端升级后若 keyId 不再匹配,需重新从 loggerGet() 取,改这里。
const wbAtRestSecretKey = "Sik9U5aXhCdwTVEwsEySDOmDoB9r9ntFxHF1fst9LQI="

// decryptWBEncrypted 递归解出 doc 里所有 $wbEncrypted 字段并重新 marshal。
// 无加密字段时返回原字节(不做二次序列化,避免把客户端文件格式改写);
// sealed 记录哪些字段原本是信封(形如 "auth.accessToken")——回写时按这份清单
// 复原,见 sealForSave。
func decryptWBEncrypted(raw []byte) (out []byte, sealed map[string]bool, err error) {
	if !bytes.Contains(raw, []byte(`"$wbEncrypted"`)) {
		return raw, nil, nil
	}
	var doc map[string]any
	if err := json.Unmarshal(raw, &doc); err != nil {
		// 交给调用方按原路径报 storage_parse_error,这里不抢错误。
		return raw, nil, nil
	}
	key := sha256.Sum256([]byte(wbAtRestSecretKey))
	sealed = map[string]bool{}
	v, changed, err := wbDecryptValue(doc, key, "", sealed)
	if err != nil || !changed {
		return raw, nil, err
	}
	out, err = json.Marshal(v)
	if err != nil {
		return nil, nil, fmt.Errorf("at_rest_marshal_failed: %w", err)
	}
	return out, sealed, nil
}

// wbDecryptValue 深度遍历;命中信封就地替换。changed=false 表示整棵树没有加密字段。
// prefix 是当前节点的路径("auth.accessToken"),命中信封时记进 sealed。
func wbDecryptValue(v any, key [32]byte, prefix string, sealed map[string]bool) (any, bool, error) {
	switch t := v.(type) {
	case map[string]any:
		if enc, ok := t["$wbEncrypted"].(float64); ok && enc == 1 {
			if env, ok := t["envelope"].(string); ok && env != "" {
				plain, err := wbDecryptEnvelope(env, key)
				if err != nil {
					return nil, false, err
				}
				sealed[prefix] = true
				return plain, true, nil
			}
		}
		changed := false
		for k, item := range t {
			nv, c, err := wbDecryptValue(item, key, wbJoinPath(prefix, k), sealed)
			if err != nil {
				return nil, false, err
			}
			if c {
				t[k] = nv
				changed = true
			}
		}
		return t, changed, nil
	case []any:
		changed := false
		for i, item := range t {
			nv, c, err := wbDecryptValue(item, key, fmt.Sprintf("%s[%d]", prefix, i), sealed)
			if err != nil {
				return nil, false, err
			}
			if c {
				t[i] = nv
				changed = true
			}
		}
		return t, changed, nil
	}
	return v, false, nil
}

// wbJoinPath 拼 sealed 路径;顶层容器不加前缀("auth.accessToken")。
func wbJoinPath(prefix, key string) string {
	if prefix == "" {
		return key
	}
	return prefix + "." + key
}

// sealForSave 只重新封装「读入时确实是信封」的字段。
//
// 为什么不按固定清单封:客户端封哪些字段是它自己的契约(实测封 accessToken /
// refreshToken / nickname / phoneNumber,expiresAt 保持明文),照我们的清单去封会把
// 它读作明文的字段也加密,桌面端就读不回来了。来源文件没加密的字段一律不碰。
// 任一字段封装失败即报错(调用方不得落盘),不静默降级成明文。
func sealForSave(doc map[string]any, sealed map[string]bool) error {
	for path := range sealed {
		parts := strings.Split(path, ".")
		if len(parts) != 2 {
			continue // accounts[]/allAccounts[] 这类我们不回写的容器,跳过
		}
		parent, ok := doc[parts[0]].(map[string]any)
		if !ok {
			continue
		}
		v, ok := parent[parts[1]]
		if !ok || v == nil {
			continue
		}
		if _, isEnvelope := v.(map[string]any); isEnvelope {
			continue // 已经是信封
		}
		env, err := sealWBValue(v)
		if err != nil {
			return err
		}
		parent[parts[1]] = env
	}
	// 凭据两个字段必须封上:漏了就是明文 token 覆盖加密文件。
	for _, k := range []string{"accessToken", "refreshToken"} {
		if authObj, ok := doc["auth"].(map[string]any); ok && sealed["auth."+k] {
			if _, isEnvelope := authObj[k].(map[string]any); !isEnvelope {
				return fmt.Errorf("at_rest_seal_failed: %s 未能封装,拒绝以明文落盘", k)
			}
		}
	}
	return nil
}

// wbDecryptEnvelope 解一个 base64 信封,返回明文解包后的值。
func wbDecryptEnvelope(envelopeB64 string, key [32]byte) (any, error) {
	rawEnv, err := base64.StdEncoding.DecodeString(envelopeB64)
	if err != nil {
		return nil, fmt.Errorf("at_rest_bad_envelope: %w", err)
	}
	var env struct {
		Suite      uint32 `json:"suite"`
		KeyID      string `json:"keyId"`
		Nonce      string `json:"nonce"`
		AuthTag    string `json:"authTag"`
		Ciphertext string `json:"ciphertext"`
	}
	if err := json.Unmarshal(rawEnv, &env); err != nil {
		return nil, fmt.Errorf("at_rest_bad_envelope: %w", err)
	}
	wantID := wbKeyID(key)
	if env.KeyID != wantID {
		return nil, fmt.Errorf("at_rest_key_mismatch: envelope keyId=%s want %s"+
			"(桌面端换了 at-rest 密钥,需重新逆向 loggerGet)", env.KeyID, wantID)
	}
	nonce, tag, ct, err := b64Triple(env.Nonce, env.AuthTag, env.Ciphertext)
	if err != nil {
		return nil, err
	}
	block, err := aes.NewCipher(key[:])
	if err != nil {
		return nil, fmt.Errorf("at_rest_cipher_failed: %w", err)
	}
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, fmt.Errorf("at_rest_gcm_failed: %w", err)
	}
	plain, err := gcm.Open(nil, nonce, append(ct, tag...), wbFieldAAD(env.Suite, env.KeyID))
	if err != nil {
		return nil, fmt.Errorf("at_rest_decrypt_failed: %w", err)
	}
	return wbDecodePlain(plain), nil
}

// wbKeyID sha256(sha256(secret)) 的 hex 前 16 位——信封里的 keyId 校验口径。
func wbKeyID(key [32]byte) string {
	h := sha256.Sum256(key[:])
	return hex.EncodeToString(h[:])[:16]
}

// wbFieldAAD 字段级 AAD(framing=2)。任意一个字节不同都会解密失败。
func wbFieldAAD(suite uint32, keyID string) []byte {
	var b bytes.Buffer
	b.WriteString("WB-AAD\x00")
	b.WriteByte(1)
	wbWriteLP(&b, "WBEV1")  // framing tag
	wbWriteLP(&b, "sym-v1") // scheme
	var u [4]byte
	binary.BigEndian.PutUint32(u[:], suite)
	b.Write(u[:])
	wbWriteLP(&b, keyID)
	b.WriteByte(2) // framing: file=1 field=2 record=3 stream=4
	b.WriteByte(0) // 无 sequence
	b.WriteByte(0) // 无 final
	return b.Bytes()
}

func wbWriteLP(b *bytes.Buffer, s string) {
	var u [4]byte
	binary.BigEndian.PutUint32(u[:], uint32(len(s)))
	b.Write(u[:])
	b.WriteString(s)
}

func b64Triple(nonce, tag, ct string) (n, t, c []byte, err error) {
	for _, f := range []struct {
		name string
		in   string
		out  *[]byte
	}{{"nonce", nonce, &n}, {"authTag", tag, &t}, {"ciphertext", ct, &c}} {
		v, e := base64.StdEncoding.DecodeString(f.in)
		if e != nil {
			return nil, nil, nil, fmt.Errorf("at_rest_bad_envelope: %s: %w", f.name, e)
		}
		*f.out = v
	}
	return n, t, c, nil
}

// wbDecodePlain 明文可能是:纯文本、JSON、或是 Buffer 形态的 JSON
// ({"type":"Buffer","data":[字节]}——UTF-8 字节包装),个别字段还会双重 JSON。
func wbDecodePlain(plain []byte) any {
	var v any
	if json.Unmarshal(plain, &v) != nil {
		return string(plain)
	}
	v = wbUnwrapBuffer(v)
	if s, ok := v.(string); ok {
		var again any
		if json.Unmarshal([]byte(s), &again) == nil {
			return wbUnwrapBuffer(again)
		}
	}
	return v
}

// sealWBValue 把一个值包成 $wbEncrypted 信封,明文取值的文本形态
// (字符串原样,其余走 JSON)。SaveAtomic 回写时用它,避免把用完就刷新的
// 凭据以明文覆盖掉桌面端的加密文件。
//
// shortcut: 只按 sym-v1/field framing 加密,不回放桌面端的 Buffer 包装形态(我们的
// 读取路径两种都认);哪天要写回给桌面端直接读的字段,再对齐包装形态。
func sealWBValue(v any) (map[string]any, error) {
	text, ok := v.(string)
	if !ok {
		b, err := json.Marshal(v)
		if err != nil {
			return nil, fmt.Errorf("at_rest_seal_failed: %w", err)
		}
		text = string(b)
	}
	key := sha256.Sum256([]byte(wbAtRestSecretKey))
	block, err := aes.NewCipher(key[:])
	if err != nil {
		return nil, fmt.Errorf("at_rest_cipher_failed: %w", err)
	}
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, fmt.Errorf("at_rest_gcm_failed: %w", err)
	}
	keyID := wbKeyID(key)
	nonce := make([]byte, gcm.NonceSize())
	if _, err := rand.Read(nonce); err != nil {
		return nil, fmt.Errorf("at_rest_seal_failed: %w", err)
	}
	ct := gcm.Seal(nil, nonce, []byte(text), wbFieldAAD(1, keyID))
	env, err := json.Marshal(map[string]any{
		"suite":      1,
		"keyId":      keyID,
		"nonce":      base64.StdEncoding.EncodeToString(nonce),
		"authTag":    base64.StdEncoding.EncodeToString(ct[len(ct)-16:]),
		"ciphertext": base64.StdEncoding.EncodeToString(ct[:len(ct)-16]),
	})
	if err != nil {
		return nil, fmt.Errorf("at_rest_seal_failed: %w", err)
	}
	return map[string]any{
		"$wbEncrypted": 1,
		"envelope":     base64.StdEncoding.EncodeToString(env),
	}, nil
}

func wbUnwrapBuffer(v any) any {
	switch t := v.(type) {
	case map[string]any:
		if t["type"] == "Buffer" {
			if arr, ok := t["data"].([]any); ok {
				buf := make([]byte, 0, len(arr))
				for _, n := range arr {
					f, ok := n.(float64)
					if !ok {
						return t // 形状不符就不解,原样留着让上层看到
					}
					buf = append(buf, byte(f))
				}
				return string(buf)
			}
		}
		for k, item := range t {
			t[k] = wbUnwrapBuffer(item)
		}
		return t
	case []any:
		for i, item := range t {
			t[i] = wbUnwrapBuffer(item)
		}
		return t
	}
	return v
}