fix(channel): M41 r1 复审三条 —— telegram 构造分支、QQ 改 MaskQuery、删两处死上限

P2-1 telegram doJSON 的**请求构造**失败分支:http.NewRequestWithContext 解析失败的
err 同样是 *url.Error(里面是整条 /bot<token>/… 地址),而 poll.go 的 long poll
failed 会原样落日志。改成与传输层分支同形:trace.HostOf(endpoint) + callCause。

P2-2 qq_obv11 connectClient 的成功 INFO 从 maskAccessTokenQuery 换成
trace.MaskQuery:后者认得 access%5Ftoken / token / api_key / 签名参数 / userinfo,
且保留 EscapedPath(路径可读)与不截断。maskAccessTokenQuery 仍被
sanitizeConnectReason 使用,未成死代码。

P2-3 删掉 maxEnvelopeMessageRunes / maxDescriptionRunes(各 200):trace.RedactText
内部已 truncate 到 maxSummaryRunes=80,这两层永不命中,注释口径与实际不符。改为
直接 return trace.RedactText(压平空白),注释写明 80 rune 由 RedactText 负责。

用例(全部变异打红,逐条验证):telegram 构造分支 token、QQ 八形态凭据矩阵
(含四种 maskAccessTokenQuery 漏掉的形态 + 路径可读反向断言)、两处 80 rune 上限。
This commit is contained in:
AskaEth committed 2026-10-26 13:58:19 +08:00
1 parent 0f9251b983
commit 4b4173dd42
6 files changed
+212 -54

No files matched your search

+4 -13
View File
@@ -33,11 +33,6 @@ var ErrAPI = errors.New("httpclient: api error")
// maxBodyBytes caps how large a response body the client will read.
const maxBodyBytes = 1 << 20 // 1 MiB
// maxEnvelopeMessageRunes caps the envelope `message` field once it enters an
// error. It is upstream free text: whatever was rejected may be echoed there, so
// it is cleaned and bounded rather than passed through at the upstream's length.
const maxEnvelopeMessageRunes = 200
// Client is a token-auth JSON HTTP client bound to a base URL.
type Client struct {
http *http.Client
@@ -208,15 +203,11 @@ func apiFailure(method, host string, resp *http.Response, raw []byte) error {
return fmt.Errorf("httpclient: %s: %w: %w", method, upstream, ErrAPI)
}
// envelopeMessage 是信封 message 进入错误前的唯一处理:压平空白、清洗凭据形状,再按
// rune 截断。message 是上游自由文本面,被拒的输入常被回显在这里。
// envelopeMessage 是信封 message 进入错误前的唯一处理:压平空白,再交给
// trace.RedactText —— 它既清洗凭据形状,也把长度压到 80 rune(超出的带省略号)。
// 上游常把被拒的输入回显在 message 里,因此这一层不是可选的。
func envelopeMessage(s string) string {
flat := strings.Join(strings.Fields(s), " ")
flat = trace.RedactText(flat)
if r := []rune(flat); len(r) > maxEnvelopeMessageRunes {
return string(r[:maxEnvelopeMessageRunes]) + "…"
}
return flat
return trace.RedactText(strings.Join(strings.Fields(s), " "))
}
// transportCause 剥掉 net/http 的 *url.Error 外壳:它会把**完整请求地址**拼进错误串
@@ -145,3 +145,28 @@ func TestGetJSON_UserinfoNeverEntersError(t *testing.T) {
t.Fatalf("user:pass@ 进了错误:%v", err)
}
}
// TestDoJSON_EnvelopeMessageIsBoundedByRedactText 钉住长度口径:信封 message 只有一道
// 清洗(trace.RedactText,80 rune + 省略号)。本片曾按 200 rune 自己再截一刀,那层
// 永远命中不了 —— 这条用例让「到底哪一层在截」变成可断言的事实。
func TestDoJSON_EnvelopeMessageIsBoundedByRedactText(t *testing.T) {
t.Parallel()
long := strings.Repeat("a", 300)
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadRequest)
_, _ = w.Write([]byte(`{"code":40101,"message":"` + long + `","data":null}`))
}))
defer srv.Close()
c := New(WithBaseURL(srv.URL), WithHTTPClient(srv.Client()), WithLogger(discardLogger()))
_, err := c.DoJSON(context.Background(), http.MethodGet, "/gateway/index", nil)
if err == nil {
t.Fatal("401 却报成功")
}
if !strings.Contains(err.Error(), strings.Repeat("a", 80)+"…") {
t.Fatalf("信封 message 没有按 80 rune 截断:%v", err)
}
if strings.Contains(err.Error(), strings.Repeat("a", 81)) {
t.Fatalf("信封 message 超过了 80 rune 上限:%v", err)
}
}
+7 -5
View File
@@ -14,6 +14,8 @@ import (
"fmt"
"net/url"
"strings"
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/trace"
)
// errClientConfig 是 client 模式配置缺失(remote_url 为空)的错误哨兵:重试治不好
@@ -61,11 +63,11 @@ func (a *Adapter) connectClient(ctx context.Context) error {
return fmt.Errorf("qq-obv11: dial onebot ws %s: %w", a.cfg.RemoteURL, cerr)
}
a.setConn(conn)
// remote_url 按 OneBot 惯例可以直接写着 `?access_token=…`,原样 INFO 就是把凭据
// 写进日志。这里复用同包已有的第二层脱敏(connect_outcome.go 的
// maskAccessTokenQuery)——不另写一套,也不用 sanitizeConnectReason 的 80 rune
// 上限,否则地址的路径会被切掉、失去「连到了哪」的诊断价值。
a.log.Info("connected to onebot ws (client mode)", "url", maskAccessTokenQuery(a.cfg.RemoteURL))
// remote_url 按 OneBot 惯例可以直接写着 `?access_token=…`,也可能是把凭据塞进
// `user:pass@` 或别的键名(`token` / `api_key` / 签名参数)。原样 INFO 就是把凭据
// 写进日志,因此只打 trace.MaskQuery 的形态:凭据类 query/fragment 值与 userinfo
// 一律打码,路径原样保留(「连到了哪个端点」是这条 INFO 的全部诊断价值)。
a.log.Info("connected to onebot ws (client mode)", "url", trace.MaskQuery(a.cfg.RemoteURL))
return nil
}
+116 -19
View File
@@ -1,8 +1,13 @@
package qq_obv11
// 本文件钉住 ws+client 连接成功那条 INFO 的出镜边界(M41 #15):
// remote_url 按 OneBot 惯例可以直接写着 `?access_token=…`,原样 INFO 就是把凭据写进
// 日志。同包 connect_outcome.go 早就有三层脱敏,这里钉的是「连接成功路径也走它」。
// 本文件钉住 ws+client 连接成功那条 INFO 的出镜边界(M41 #15):remote_url 可以带
// 凭据 —— OneBot 惯例是 `?access_token=`,但真实配置里也见过 `?token=`、`?api_key=`、
// 签名参数,以及 `user:pass@`。原样 INFO 就是把凭据写进日志。
//
// 打码走 trace.MaskQuery(同包 maskAccessTokenQuery 只认 access_token 一个键名,复审
// 形态矩阵里 `access%5Ftoken` / `token` / `api_key` / 签名 / userinfo 五种形态都不认)。
// 这条 INFO 的全部诊断价值是「连到了哪个端点」,因此路径必须原样可读 —— 每个用例都
// 反向断言这一点。
import (
"context"
@@ -12,12 +17,10 @@ import (
"testing"
)
// TestConnectClientInfoLogMasksAccessToken 远端 URL 带 access_token 时,成功日志里
// 不得出现 token 明文;把脱敏改回原样传参就变红。
func TestConnectClientInfoLogMasksAccessToken(t *testing.T) {
t.Parallel()
const secret = "ONEBOT-ACCESS-TOKEN-SECRET"
// wsServerForLogTest 起一个只说「握手 + 保持连接」的假 OneBot 服务端。它不解析路径与
// 查询串,因此下面每条形态都能连得上,测的纯粹是日志字段。
func wsServerForLogTest(t *testing.T) *httptest.Server {
t.Helper()
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := upgradeWS(w, r)
if err != nil {
@@ -30,25 +33,119 @@ func TestConnectClientInfoLogMasksAccessToken(t *testing.T) {
}
}
}))
defer srv.Close()
t.Cleanup(srv.Close)
return srv
}
remote := "ws://" + strings.TrimPrefix(srv.URL, "http://") + "/?access_token=" + secret
// connectAndLog 用给定的远端 URL 连一次,返回这段时间的全部日志文本。
func connectAndLog(t *testing.T, remote string) string {
t.Helper()
logs, logger := logCaptureSync()
a := NewAdapter(Config{Mode: "client", RemoteURL: remote}, WithLogger(logger))
if err := a.Connect(context.Background()); err != nil {
t.Fatalf("Connect: %v", err)
t.Fatalf("Connect(%q): %v", remote, err)
}
defer func() { _ = a.Disconnect(context.Background()) }()
t.Cleanup(func() { _ = a.Disconnect(context.Background()) })
logged := logs.text()
if !strings.Contains(logged, "connected to onebot ws") {
t.Fatalf("没有连接成功日志,测试没覆盖到目标路径:\n%s", logged)
}
if strings.Contains(logged, secret) {
t.Fatalf("access_token 明文进了 INFO 日志:\n%s", logged)
return logged
}
// TestConnectClientInfoLogMasksCredentials 是「凭据形态 × 打码」的矩阵:每种形态都要求
// 凭据搜不到、打码标记在场、路径仍可读。
func TestConnectClientInfoLogMasksCredentials(t *testing.T) {
srv := wsServerForLogTest(t)
hostport := strings.TrimPrefix(srv.URL, "http://")
const secret = "SECRET-VALUE-1234"
const path = "/onebot/v11/ws"
cases := []struct {
name string
url string
// leaked 是**不得出现**的子串(明文凭据的形态)。
leaked string
// masked 是**必须出现**的打码结果片段,兼作「这条日志确实带了该字段」的反向断言。
masked string
}{
{
name: "access_token_query",
url: "ws://" + hostport + path + "?access_token=" + secret,
leaked: secret,
masked: "?access_token=***",
},
{
name: "access_token_after_other_query",
url: "ws://" + hostport + path + "?compress=0&access_token=" + secret,
leaked: secret,
masked: "&access_token=***",
},
{
name: "percent_encoded_key",
url: "ws://" + hostport + path + "?access%5Ftoken=" + secret,
leaked: secret,
masked: "?access%5Ftoken=***",
},
{
name: "generic_token_key",
url: "ws://" + hostport + path + "?token=" + secret,
leaked: secret,
masked: "?token=***",
},
{
name: "api_key_key",
url: "ws://" + hostport + path + "?api_key=" + secret,
leaked: secret,
masked: "?api_key=***",
},
{
name: "signature_key",
url: "ws://" + hostport + path + "?X-Signature=" + secret,
leaked: secret,
masked: "?X-Signature=***",
},
{
name: "fragment_token",
url: "ws://" + hostport + path + "#access_token=" + secret,
leaked: secret,
masked: "#access_token=***",
},
{
name: "userinfo",
url: "ws://apiuser:" + secret + "@" + hostport + path,
leaked: secret,
masked: "ws://[redacted]@" + hostport + path,
},
}
// 反向断言:确实打了脱敏占位符,而不是「这条日志压根没带 url 字段」。
if !strings.Contains(logged, "access_token="+maskedCredential) {
t.Fatalf("日志里既没有明文也没有脱敏占位符,脱敏可能被绕过了:\n%s", logged)
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
logged := connectAndLog(t, tc.url)
t.Logf("before=%q after=%s", tc.url, urlField(logged))
if strings.Contains(logged, tc.leaked) {
t.Fatalf("凭据明文进了 INFO 日志:\n%s", logged)
}
if !strings.Contains(logged, tc.masked) {
t.Fatalf("日志里没有打码结果 %q:\n%s", tc.masked, logged)
}
// 反向断言:路径必须还在 —— 否则「连到了哪个端点」这条诊断就没了。
if !strings.Contains(logged, path) {
t.Fatalf("日志丢了路径 %q:\n%s", path, logged)
}
})
}
}
// urlField 摘出日志里 `url=…` 字段的值(渲染后可能带引号),只用于测试输出。
func urlField(logged string) string {
for _, line := range strings.Split(logged, "\n") {
if !strings.Contains(line, "connected to onebot ws") {
continue
}
if i := strings.Index(line, " url="); i >= 0 {
return line[i+1:]
}
}
return ""
}
+9 -17
View File
@@ -24,14 +24,8 @@ type botResponse struct {
ErrorCode int `json:"error_code"`
}
const (
// maxErrorBodyBytes caps how much of a non-200 reply is read before classifying it.
maxErrorBodyBytes = 512
// maxDescriptionRunes caps the description once it enters an error. Telegram's
// description is upstream free text (it can echo the parameter we sent), so it
// is cleaned and bounded instead of being passed through verbatim.
maxDescriptionRunes = 200
)
// maxErrorBodyBytes caps how much of a non-200 reply is read before classifying it.
const maxErrorBodyBytes = 512
// doJSON posts a JSON payload to a Bot API method and decodes the envelope. The
// caller is responsible for decoding Result; a non-OK reply is returned as
@@ -45,7 +39,10 @@ func (a *Adapter) doJSON(ctx context.Context, method string, payload any) (*botR
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, a.endpoint(method), &buf)
if err != nil {
return nil, fmt.Errorf("telegram: build %s request: %w", method, err)
// 解析失败的 err 同样是 *url.Error(里面是整条 /bot<token>/… 地址),因此与
// 下面的传输层分支同形处理:只留来源,地址由 callCause 剥掉。
return nil, fmt.Errorf("telegram: build %s request %s: %w",
method, trace.HostOf(a.endpoint(method)), callCause(err))
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/json")
@@ -234,15 +231,10 @@ func badResponseError(method string, status int, body []byte) error {
return fmt.Errorf("%s: %w", strings.Join(parts, ": "), ErrBadResponse)
}
// boundedDescription 是 Bot API description 进入错误前的唯一处理:压平空白、清洗
// 凭据形状,再按 rune 截断(宁可丢细节,不可把一段回显整段带出来)。
// boundedDescription 是 Bot API description 进入错误前的唯一处理:压平空白,再交给
// trace.RedactText —— 它既清洗凭据形状,也把长度压到 80 rune(超出的带省略号)。
func boundedDescription(s string) string {
flat := strings.Join(strings.Fields(s), " ")
flat = trace.RedactText(flat)
if r := []rune(flat); len(r) > maxDescriptionRunes {
return string(r[:maxDescriptionRunes]) + "…"
}
return flat
return trace.RedactText(strings.Join(strings.Fields(s), " "))
}
// callCause 剥掉 net/http 的 *url.Error 外壳:它会把完整地址拼进错误串,而 Bot API
@@ -101,3 +101,54 @@ func TestDoJSON_TransportErrorOmitsBotToken(t *testing.T) {
t.Fatalf("剥掉地址时把来源或原因一起丢了:%v", err)
}
}
// TestDoJSON_BuildErrorOmitsBotToken 请求**构造**失败也是同一族:地址解析失败的
// err 同样是 *url.Error,里面就是整条 /bot<token>/… 地址,而 poll.go 会原样落日志。
// 与传输层分支同形:只留来源,原因保留。
func TestDoJSON_BuildErrorOmitsBotToken(t *testing.T) {
t.Parallel()
const token = "424242:PROBE-BUILD-TOKEN"
a := New(
Config{BotToken: token},
// 控制字符让 url.Parse 失败 —— 这是「构造请求」分支唯一现实的触发方式。
WithBaseURL("http://api.example.com/\x7f"),
WithLogger(discardLogger()),
)
_, err := a.doJSON(context.Background(), "getUpdates", nil)
if err == nil {
t.Fatal("构造失败却报成功")
}
if strings.Contains(err.Error(), token) {
t.Fatalf("bot token 随地址进了错误(会随 long poll failed 落日志):%v", err)
}
if !strings.Contains(err.Error(), "build getUpdates request") {
t.Fatalf("错误没说是哪个方法的构造失败:%v", err)
}
if !strings.Contains(err.Error(), "net/url") && !strings.Contains(err.Error(), "invalid") {
t.Fatalf("剥掉地址时把原因一起丢了:%v", err)
}
}
// TestDoJSON_DescriptionIsBoundedByRedactText 钉住长度口径:description 只有一道
// 清洗(trace.RedactText,80 rune + 省略号)。本片曾按 200 rune 自己再截一刀,那层
// 永远命中不了 —— 这条用例让「到底哪一层在截」变成可断言的事实。
func TestDoJSON_DescriptionIsBoundedByRedactText(t *testing.T) {
t.Parallel()
long := strings.Repeat("a", 300)
a, _ := newTestAdapter(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadRequest)
_, _ = w.Write([]byte(`{"ok":false,"error_code":400,"description":"` + long + `"}`))
}))
_, err := a.doJSON(context.Background(), "getMe", nil)
if err == nil {
t.Fatal("400 却报成功")
}
if !strings.Contains(err.Error(), strings.Repeat("a", 80)+"…") {
t.Fatalf("description 没有按 80 rune 截断:%v", err)
}
if strings.Contains(err.Error(), strings.Repeat("a", 81)) {
t.Fatalf("description 超过了 80 rune 上限:%v", err)
}
}