This commit is contained in:
yml2213
2026-07-06 18:08:23 +08:00
commit 4235cce4f5
49 changed files with 9880 additions and 0 deletions
+518
View File
@@ -0,0 +1,518 @@
package gui
import (
"context"
"errors"
"fmt"
"strconv"
"strings"
"sync"
"time"
"github.com/wailsapp/wails/v2/pkg/runtime"
"huya-go/internal/huya"
"huya-go/internal/sniper"
)
const (
eventLog = "gui:log"
eventMonitorResult = "gui:monitor-result"
eventMonitorState = "gui:monitor-state"
maxLogEntries = 500
)
type App struct {
ctx context.Context
logMu sync.Mutex
logs []LogEntry
runMu sync.Mutex
monitorCancel context.CancelFunc
monitorRunning bool
}
type Config struct {
Transport string `json:"transport"`
WSSHost string `json:"wssHost"`
SID int32 `json:"sid"`
PID int32 `json:"pid"`
Name string `json:"name"`
CookieText string `json:"cookieText"`
Loops int `json:"loops"`
DelayMS int `json:"delayMs"`
Concurrency int `json:"concurrency"`
StopAfterSuccess bool `json:"stopAfterSuccess"`
TimeoutSec int `json:"timeoutSec"`
StartAt string `json:"startAt"`
}
type AccountPreview struct {
Line int `json:"line"`
UID int64 `json:"uid"`
Valid bool `json:"valid"`
Error string `json:"error,omitempty"`
}
type LogEntry struct {
Time string `json:"time"`
Level string `json:"level"`
Message string `json:"message"`
}
type PrizeListResult struct {
UID int64 `json:"uid"`
Status int32 `json:"status"`
Msg string `json:"msg"`
Prizes []huya.PrizeInfo `json:"prizes"`
Raw *huya.GetActPrizeListResp `json:"raw,omitempty"`
}
type ScoreResult struct {
UID int64 `json:"uid"`
Score int64 `json:"score"`
Resp *huya.GetUserScoreResp `json:"resp,omitempty"`
Error string `json:"error,omitempty"`
}
type RecordResult struct {
UID int64 `json:"uid"`
Records []huya.UserPrizeInfo `json:"records"`
Resp *huya.GetUserPrizeRecordsResp `json:"resp,omitempty"`
Error string `json:"error,omitempty"`
}
type ExchangeResult struct {
UID int64 `json:"uid"`
Resp *huya.ScoreExchangePrizeResp `json:"resp,omitempty"`
Error string `json:"error,omitempty"`
}
type MonitorState struct {
Running bool `json:"running"`
Message string `json:"message"`
}
type cookieLine struct {
lineNo int
text string
}
func NewApp() *App {
return &App{}
}
func (a *App) Startup(ctx context.Context) {
a.ctx = ctx
a.addLog("info", "GUI 已启动")
}
func (a *App) Shutdown(ctx context.Context) {
a.StopMonitor()
}
func (a *App) DefaultConfig() Config {
return Config{
Transport: "wss",
WSSHost: huya.DefaultWSSHost,
SID: 2203,
PID: 12889,
Name: "小黄鸭",
Loops: 20,
DelayMS: 120,
Concurrency: 5,
StopAfterSuccess: true,
TimeoutSec: 15,
}
}
func (a *App) PreviewAccounts(cookieText string) []AccountPreview {
previews := make([]AccountPreview, 0)
for _, line := range splitCookieLines(cookieText) {
uid := huya.ResolveUID(line.text)
item := AccountPreview{Line: line.lineNo, UID: uid, Valid: uid > 0}
if uid <= 0 {
item.Error = "无法解析 yyuid/udb_uid"
}
previews = append(previews, item)
}
return previews
}
func (a *App) GetLogs() []LogEntry {
a.logMu.Lock()
defer a.logMu.Unlock()
return append([]LogEntry(nil), a.logs...)
}
func (a *App) IsRunning() bool {
a.runMu.Lock()
defer a.runMu.Unlock()
return a.monitorRunning
}
func (a *App) ListPrizes(cfg Config) (PrizeListResult, error) {
cfg = normalizeConfig(cfg)
accounts, err := parseAccounts(cfg.CookieText)
if err != nil {
return PrizeListResult{}, err
}
if cfg.SID <= 0 {
return PrizeListResult{}, errors.New("SID 不能为空")
}
client, closeClient, err := a.newClient(cfg)
if err != nil {
return PrizeListResult{}, err
}
defer closeClient()
ctx, cancel := requestContext(cfg.TimeoutSec)
defer cancel()
resp, err := client.GetActPrizeList(ctx, accounts[0].UID, accounts[0].Cookie, cfg.SID)
if err != nil {
a.addLog("error", "查询奖品失败: %v", err)
return PrizeListResult{}, err
}
a.addLog("info", "查询奖品完成: uid=%d sid=%d count=%d", accounts[0].UID, cfg.SID, len(resp.Prizes))
return PrizeListResult{
UID: accounts[0].UID,
Status: resp.Status,
Msg: resp.Msg,
Prizes: resp.Prizes,
Raw: resp,
}, nil
}
func (a *App) QueryScores(cfg Config) ([]ScoreResult, error) {
cfg = normalizeConfig(cfg)
accounts, err := parseAccounts(cfg.CookieText)
if err != nil {
return nil, err
}
if cfg.SID <= 0 {
return nil, errors.New("SID 不能为空")
}
client, closeClient, err := a.newClient(cfg)
if err != nil {
return nil, err
}
defer closeClient()
results := make([]ScoreResult, len(accounts))
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
ctx, cancel := requestContext(cfg.TimeoutSec)
defer cancel()
resp, err := client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID)
item := ScoreResult{UID: account.UID, Resp: resp, Error: errorString(err)}
if resp != nil {
item.Score = resp.AvailableScore()
}
results[i] = item
})
a.addLog("info", "查询积分完成: accounts=%d", len(accounts))
return results, nil
}
func (a *App) GetRecords(cfg Config) ([]RecordResult, error) {
cfg = normalizeConfig(cfg)
accounts, err := parseAccounts(cfg.CookieText)
if err != nil {
return nil, err
}
if cfg.SID <= 0 {
return nil, errors.New("SID 不能为空")
}
client, closeClient, err := a.newClient(cfg)
if err != nil {
return nil, err
}
defer closeClient()
results := make([]RecordResult, len(accounts))
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
ctx, cancel := requestContext(cfg.TimeoutSec)
defer cancel()
resp, err := client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID)
item := RecordResult{UID: account.UID, Resp: resp, Error: errorString(err)}
if resp != nil {
item.Records = resp.Records
}
results[i] = item
})
a.addLog("info", "查询兑换记录完成: accounts=%d", len(accounts))
return results, nil
}
func (a *App) Exchange(cfg Config) ([]ExchangeResult, error) {
cfg = normalizeConfig(cfg)
accounts, err := parseAccounts(cfg.CookieText)
if err != nil {
return nil, err
}
if cfg.SID <= 0 || cfg.PID <= 0 {
return nil, errors.New("SID 和 PID 都不能为空")
}
client, closeClient, err := a.newClient(cfg)
if err != nil {
return nil, err
}
defer closeClient()
results := make([]ExchangeResult, len(accounts))
a.runConcurrent(accounts, cfg.Concurrency, func(i int, account sniper.Account) {
ctx, cancel := requestContext(cfg.TimeoutSec)
defer cancel()
resp, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, cfg.SID, cfg.PID)
results[i] = ExchangeResult{UID: account.UID, Resp: resp, Error: errorString(err)}
})
a.addLog("info", "直接兑换完成: sid=%d pid=%d accounts=%d", cfg.SID, cfg.PID, len(accounts))
return results, nil
}
func (a *App) StartMonitor(cfg Config) error {
cfg = normalizeConfig(cfg)
accounts, err := parseAccounts(cfg.CookieText)
if err != nil {
return err
}
if cfg.SID <= 0 {
return errors.New("SID 不能为空")
}
if cfg.PID <= 0 && strings.TrimSpace(cfg.Name) == "" {
return errors.New("PID 和名称至少填写一个")
}
startAt, err := parseStartTime(cfg.StartAt)
if err != nil {
return err
}
a.runMu.Lock()
if a.monitorRunning {
a.runMu.Unlock()
return errors.New("监控已在运行")
}
ctx, cancel := context.WithCancel(context.Background())
a.monitorCancel = cancel
a.monitorRunning = true
a.runMu.Unlock()
client, closeClient, err := a.newClient(cfg)
if err != nil {
cancel()
a.finishMonitor("启动失败")
return err
}
a.emitState(true, "运行中")
a.addLog("info", "启动监控: sid=%d pid=%d name=%s accounts=%d", cfg.SID, cfg.PID, cfg.Name, len(accounts))
go func() {
defer closeClient()
defer a.finishMonitor("已停止")
if !startAt.IsZero() {
a.addLog("info", "等待定时开始: %s", startAt.Format("2006-01-02 15:04:05"))
if err := waitUntil(ctx, startAt); err != nil {
a.addLog("info", "定时等待已取消")
return
}
}
runner := sniper.Runner{Client: client}
err := runner.Run(ctx, accounts, sniper.Target{
PID: cfg.PID,
Name: strings.TrimSpace(cfg.Name),
}, sniper.Config{
SID: cfg.SID,
Loops: cfg.Loops,
Delay: time.Duration(cfg.DelayMS) * time.Millisecond,
Concurrency: cfg.Concurrency,
StopAfterSuccess: cfg.StopAfterSuccess,
}, func(result sniper.Result) {
a.emit(eventMonitorResult, result)
a.addLog("info", "监控结果: loop=%d uid=%d action=%s error=%s", result.Loop, result.UID, result.Action, result.Error)
})
if err != nil && !errors.Is(err, context.Canceled) {
a.addLog("error", "监控结束异常: %v", err)
}
}()
return nil
}
func (a *App) StopMonitor() bool {
a.runMu.Lock()
cancel := a.monitorCancel
a.runMu.Unlock()
if cancel == nil {
return false
}
cancel()
return true
}
func (a *App) newClient(cfg Config) (huya.ActivityClient, func(), error) {
return huya.NewActivityClient(cfg.Transport, cfg.WSSHost, time.Duration(cfg.TimeoutSec)*time.Second, func(msg string) {
a.addLog("debug", "%s", msg)
})
}
func (a *App) runConcurrent(accounts []sniper.Account, concurrency int, fn func(i int, account sniper.Account)) {
if concurrency <= 0 {
concurrency = 1
}
sem := make(chan struct{}, concurrency)
var wg sync.WaitGroup
for i, account := range accounts {
i, account := i, account
wg.Add(1)
go func() {
defer wg.Done()
sem <- struct{}{}
defer func() { <-sem }()
fn(i, account)
}()
}
wg.Wait()
}
func (a *App) finishMonitor(message string) {
a.runMu.Lock()
a.monitorCancel = nil
a.monitorRunning = false
a.runMu.Unlock()
a.emitState(false, message)
}
func (a *App) addLog(level, format string, args ...any) {
entry := LogEntry{
Time: time.Now().Format("15:04:05.000"),
Level: level,
Message: fmt.Sprintf(format, args...),
}
a.logMu.Lock()
a.logs = append(a.logs, entry)
if len(a.logs) > maxLogEntries {
a.logs = append([]LogEntry(nil), a.logs[len(a.logs)-maxLogEntries:]...)
}
a.logMu.Unlock()
a.emit(eventLog, entry)
}
func (a *App) emitState(running bool, message string) {
a.emit(eventMonitorState, MonitorState{Running: running, Message: message})
}
func (a *App) emit(event string, data any) {
if a.ctx == nil {
return
}
runtime.EventsEmit(a.ctx, event, data)
}
func normalizeConfig(cfg Config) Config {
if strings.TrimSpace(cfg.Transport) == "" {
cfg.Transport = "wss"
}
if strings.TrimSpace(cfg.WSSHost) == "" {
cfg.WSSHost = huya.DefaultWSSHost
}
if cfg.Loops <= 0 {
cfg.Loops = 1
}
if cfg.DelayMS <= 0 {
cfg.DelayMS = 150
}
if cfg.Concurrency <= 0 {
cfg.Concurrency = 1
}
if cfg.TimeoutSec <= 0 {
cfg.TimeoutSec = 15
}
cfg.Name = strings.TrimSpace(cfg.Name)
cfg.CookieText = strings.TrimSpace(cfg.CookieText)
cfg.StartAt = strings.TrimSpace(cfg.StartAt)
return cfg
}
func parseAccounts(cookieText string) ([]sniper.Account, error) {
lines := splitCookieLines(cookieText)
if len(lines) == 0 {
return nil, errors.New("Cookie 不能为空")
}
accounts := make([]sniper.Account, 0, len(lines))
for _, cookie := range lines {
uid := huya.ResolveUID(cookie.text)
if uid <= 0 {
return nil, fmt.Errorf("第 %d 行 Cookie 无法解析 yyuid/udb_uid", cookie.lineNo)
}
accounts = append(accounts, sniper.Account{UID: uid, Cookie: cookie.text})
}
return accounts, nil
}
func splitCookieLines(cookieText string) []cookieLine {
lines := strings.Split(cookieText, "\n")
out := make([]cookieLine, 0, len(lines))
for i, line := range lines {
item := strings.TrimSpace(line)
if item == "" || strings.HasPrefix(item, "#") {
continue
}
out = append(out, cookieLine{lineNo: i + 1, text: item})
}
return out
}
func requestContext(timeoutSec int) (context.Context, context.CancelFunc) {
if timeoutSec <= 0 {
timeoutSec = 15
}
return context.WithTimeout(context.Background(), time.Duration(timeoutSec)*time.Second)
}
func parseStartTime(text string) (time.Time, error) {
text = strings.TrimSpace(text)
if text == "" {
return time.Time{}, nil
}
if ts, err := strconv.ParseInt(text, 10, 64); err == nil {
return time.Unix(ts, 0), nil
}
for _, layout := range []string{time.RFC3339, "2006-01-02 15:04:05", "2006-01-02 15:04"} {
if t, err := time.ParseInLocation(layout, text, time.Local); err == nil {
return t, nil
}
}
return time.Time{}, fmt.Errorf("无法解析开始时间: %s", text)
}
func waitUntil(ctx context.Context, when time.Time) error {
for {
remaining := time.Until(when)
if remaining <= 0 {
return nil
}
timer := time.NewTimer(minDuration(remaining, 200*time.Millisecond))
select {
case <-timer.C:
case <-ctx.Done():
timer.Stop()
return ctx.Err()
}
}
}
func minDuration(a, b time.Duration) time.Duration {
if a < b {
return a
}
return b
}
func errorString(err error) string {
if err == nil {
return ""
}
return err.Error()
}
+581
View File
@@ -0,0 +1,581 @@
package huya
import (
"math"
"strconv"
"strings"
"huya-go/internal/taf"
)
const (
ActivityWebUA = "web&1.0&huya"
ActivityRecordUA = "webh5&1.0.0&huya"
ActivityBindUA = "pc&1.0.0&huya"
ServantWebActUI = "webActUI"
FuncGetUserScore = "getUserScore"
FuncPrizeList = "getActPrizeList"
FuncPrizeRecords = "getUserPrizeRecords"
FuncExchangePrize = "scoreExchangePrize"
)
type ActivityUserID struct {
UID int64 `json:"uid"`
GUID string `json:"guid,omitempty"`
Token string `json:"token,omitempty"`
HuyaUA string `json:"huya_ua"`
Cookie string `json:"-"`
TokenType int32 `json:"token_type"`
DeviceInfo string `json:"device_info,omitempty"`
}
func NewActivityUserID(uid int64, cookie, ua string) ActivityUserID {
return ActivityUserID{
UID: uid,
HuyaUA: ua,
Cookie: NormalizeCookie(cookie),
TokenType: 0,
}
}
func (u *ActivityUserID) WriteTo(w *taf.Writer) error {
if err := w.WriteInt64(0, u.UID); err != nil {
return err
}
if err := w.WriteString(1, u.GUID); err != nil {
return err
}
if err := w.WriteString(2, u.Token); err != nil {
return err
}
if err := w.WriteString(3, u.HuyaUA); err != nil {
return err
}
if err := w.WriteString(4, u.Cookie); err != nil {
return err
}
if err := w.WriteInt32(5, int64(u.TokenType)); err != nil {
return err
}
return w.WriteString(6, u.DeviceInfo)
}
func (u *ActivityUserID) ReadFrom(r *taf.Reader) error {
var err error
if u.UID, err = r.ReadInt64(0, false, u.UID); err != nil {
return err
}
if u.GUID, err = r.ReadString(1, false, u.GUID); err != nil {
return err
}
if u.Token, err = r.ReadString(2, false, u.Token); err != nil {
return err
}
if u.HuyaUA, err = r.ReadString(3, false, u.HuyaUA); err != nil {
return err
}
if u.Cookie, err = r.ReadString(4, false, u.Cookie); err != nil {
return err
}
if u.TokenType, err = r.ReadInt32(5, false, u.TokenType); err != nil {
return err
}
u.DeviceInfo, err = r.ReadString(6, false, u.DeviceInfo)
return err
}
type GetUserScoreReq struct {
User ActivityUserID
SID int32
}
func (q *GetUserScoreReq) WriteTo(w *taf.Writer) error {
if err := w.WriteStruct(0, &q.User); err != nil {
return err
}
return w.WriteInt32(1, int64(q.SID))
}
func (q *GetUserScoreReq) ReadFrom(r *taf.Reader) error {
_, err := r.ReadStruct(0, false, &q.User)
if err != nil {
return err
}
q.SID, err = r.ReadInt32(1, false, q.SID)
return err
}
type GetUserScoreResp struct {
Status int32 `json:"status"`
Msg string `json:"msg"`
GainScore int32 `json:"gain_score"`
UsedScore int32 `json:"used_score"`
NewGainScore int64 `json:"new_gain_score"`
NewUsedScore int64 `json:"new_used_score"`
Score int64 `json:"score"`
IsOpenExchangeTip int32 `json:"is_open_exchange_tip"`
}
func (r *GetUserScoreResp) WriteTo(w *taf.Writer) error { return nil }
func (r *GetUserScoreResp) ReadFrom(rd *taf.Reader) error {
var err error
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
return err
}
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
return err
}
if r.GainScore, err = rd.ReadInt32(2, false, r.GainScore); err != nil {
return err
}
if r.UsedScore, err = rd.ReadInt32(3, false, r.UsedScore); err != nil {
return err
}
if r.NewGainScore, err = rd.ReadInt64(4, false, r.NewGainScore); err != nil {
return err
}
if r.NewUsedScore, err = rd.ReadInt64(5, false, r.NewUsedScore); err != nil {
return err
}
if r.Score, err = rd.ReadInt64(6, false, r.Score); err != nil {
return err
}
r.IsOpenExchangeTip, err = rd.ReadInt32(7, false, r.IsOpenExchangeTip)
return err
}
func (r GetUserScoreResp) AvailableScore() int64 {
if r.NewGainScore != 0 || r.NewUsedScore != 0 {
score := r.NewGainScore - r.NewUsedScore
if score < 0 {
return 0
}
return score
}
return r.Score
}
type GetActPrizeListReq struct {
User ActivityUserID
SID int32
}
func (q *GetActPrizeListReq) WriteTo(w *taf.Writer) error {
if err := w.WriteStruct(0, &q.User); err != nil {
return err
}
return w.WriteInt32(1, int64(q.SID))
}
func (q *GetActPrizeListReq) ReadFrom(r *taf.Reader) error {
_, err := r.ReadStruct(0, false, &q.User)
if err != nil {
return err
}
q.SID, err = r.ReadInt32(1, false, q.SID)
return err
}
type PrizeInfo struct {
ID int64 `json:"id"`
SID int64 `json:"sid"`
Name string `json:"name"`
Score int64 `json:"score"`
Type int32 `json:"type"`
Image string `json:"img,omitempty"`
Sort int32 `json:"sort"`
Frequency int32 `json:"frequency"`
FrequencyLimit int32 `json:"frequency_limit"`
CreateTime int64 `json:"create_time"`
Num int64 `json:"num"`
Status int32 `json:"status"`
Percent string `json:"percent"`
NewScore int64 `json:"new_score"`
Tags string `json:"tags,omitempty"`
LeftNum int64 `json:"left_num"`
IsShowNum int32 `json:"is_show_num"`
}
func (p *PrizeInfo) WriteTo(w *taf.Writer) error { return nil }
func (p *PrizeInfo) ReadFrom(r *taf.Reader) error {
var err error
if p.ID, err = r.ReadInt64(0, false, p.ID); err != nil {
return err
}
if p.SID, err = r.ReadInt64(1, false, p.SID); err != nil {
return err
}
if p.Name, err = r.ReadString(2, false, p.Name); err != nil {
return err
}
if p.Score, err = r.ReadInt64(3, false, p.Score); err != nil {
return err
}
if p.Type, err = r.ReadInt32(4, false, p.Type); err != nil {
return err
}
if p.Image, err = r.ReadString(5, false, p.Image); err != nil {
return err
}
if p.Sort, err = r.ReadInt32(6, false, p.Sort); err != nil {
return err
}
if p.Frequency, err = r.ReadInt32(7, false, p.Frequency); err != nil {
return err
}
if p.FrequencyLimit, err = r.ReadInt32(8, false, p.FrequencyLimit); err != nil {
return err
}
if p.CreateTime, err = r.ReadInt64(9, false, p.CreateTime); err != nil {
return err
}
if p.Num, err = r.ReadInt64(10, false, p.Num); err != nil {
return err
}
if p.Status, err = r.ReadInt32(11, false, p.Status); err != nil {
return err
}
if p.Percent, err = r.ReadString(12, false, p.Percent); err != nil {
return err
}
if p.NewScore, err = r.ReadInt64(13, false, p.NewScore); err != nil {
return err
}
if p.Tags, err = r.ReadString(14, false, p.Tags); err != nil {
return err
}
if p.LeftNum, err = r.ReadInt64(15, false, p.LeftNum); err != nil {
return err
}
p.IsShowNum, err = r.ReadInt32(16, false, p.IsShowNum)
return err
}
func (p PrizeInfo) Price() int64 {
if p.NewScore != 0 {
return p.NewScore
}
return p.Score
}
func (p PrizeInfo) EstimatedLeft() int64 {
if p.LeftNum > 0 {
return p.LeftNum
}
text := strings.TrimSuffix(strings.TrimSpace(p.Percent), "%")
if text == "" || p.Num <= 0 {
return 0
}
percent, err := strconv.ParseFloat(text, 64)
if err != nil {
return 0
}
return int64(math.Floor(float64(p.Num)*percent/100.0 + 1e-9))
}
type PrizeTag struct {
ID int64 `json:"id"`
Name string `json:"name"`
Weight int32 `json:"weight"`
}
func (t *PrizeTag) WriteTo(w *taf.Writer) error { return nil }
func (t *PrizeTag) ReadFrom(r *taf.Reader) error {
var err error
if t.ID, err = r.ReadInt64(0, false, t.ID); err != nil {
return err
}
if t.Name, err = r.ReadString(1, false, t.Name); err != nil {
return err
}
t.Weight, err = r.ReadInt32(2, false, t.Weight)
return err
}
type GetActPrizeListResp struct {
Status int32 `json:"status"`
Msg string `json:"msg"`
Prizes []PrizeInfo `json:"prizes"`
ModuleID int32 `json:"module_id"`
Tags []PrizeTag `json:"tags"`
}
func (r *GetActPrizeListResp) WriteTo(w *taf.Writer) error { return nil }
func (r *GetActPrizeListResp) ReadFrom(rd *taf.Reader) error {
var err error
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
return err
}
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
return err
}
items, err := rd.ReadListStruct(2, false, func() taf.Unmarshaler { return &PrizeInfo{} })
if err != nil {
return err
}
r.Prizes = make([]PrizeInfo, 0, len(items))
for _, item := range items {
if prize, ok := item.(*PrizeInfo); ok {
r.Prizes = append(r.Prizes, *prize)
}
}
if r.ModuleID, err = rd.ReadInt32(3, false, r.ModuleID); err != nil {
return err
}
tags, err := rd.ReadListStruct(4, false, func() taf.Unmarshaler { return &PrizeTag{} })
if err != nil {
return err
}
r.Tags = make([]PrizeTag, 0, len(tags))
for _, item := range tags {
if tag, ok := item.(*PrizeTag); ok {
r.Tags = append(r.Tags, *tag)
}
}
return nil
}
type GetUserPrizeRecordsReq struct {
User ActivityUserID
SID int32
}
func (q *GetUserPrizeRecordsReq) WriteTo(w *taf.Writer) error {
if err := w.WriteStruct(0, &q.User); err != nil {
return err
}
return w.WriteInt32(1, int64(q.SID))
}
func (q *GetUserPrizeRecordsReq) ReadFrom(r *taf.Reader) error {
_, err := r.ReadStruct(0, false, &q.User)
if err != nil {
return err
}
q.SID, err = r.ReadInt32(1, false, q.SID)
return err
}
type UserPrizeInfo struct {
ID int64 `json:"id"`
Name string `json:"name"`
Score int64 `json:"score"`
CreateTime int64 `json:"create_time"`
Status int32 `json:"status"`
Type int32 `json:"type"`
IsReal int32 `json:"is_real"`
NewScore int64 `json:"new_score"`
Account string `json:"account,omitempty"`
Code string `json:"code,omitempty"`
CommonPrizeType int32 `json:"common_prize_type"`
}
func (p *UserPrizeInfo) WriteTo(w *taf.Writer) error { return nil }
func (p *UserPrizeInfo) ReadFrom(r *taf.Reader) error {
var err error
if p.ID, err = r.ReadInt64(0, false, p.ID); err != nil {
return err
}
if p.Name, err = r.ReadString(1, false, p.Name); err != nil {
return err
}
if p.Score, err = r.ReadInt64(2, false, p.Score); err != nil {
return err
}
if p.CreateTime, err = r.ReadInt64(3, false, p.CreateTime); err != nil {
return err
}
if p.Status, err = r.ReadInt32(4, false, p.Status); err != nil {
return err
}
if p.Type, err = r.ReadInt32(5, false, p.Type); err != nil {
return err
}
if p.IsReal, err = r.ReadInt32(6, false, p.IsReal); err != nil {
return err
}
if p.NewScore, err = r.ReadInt64(7, false, p.NewScore); err != nil {
return err
}
if p.Account, err = r.ReadString(8, false, p.Account); err != nil {
return err
}
if p.Code, err = r.ReadString(9, false, p.Code); err != nil {
return err
}
p.CommonPrizeType, err = r.ReadInt32(10, false, p.CommonPrizeType)
return err
}
type GetUserPrizeRecordsResp struct {
Status int32 `json:"status"`
Msg string `json:"msg"`
Records []UserPrizeInfo `json:"records"`
}
func (r *GetUserPrizeRecordsResp) WriteTo(w *taf.Writer) error { return nil }
func (r *GetUserPrizeRecordsResp) ReadFrom(rd *taf.Reader) error {
var err error
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
return err
}
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
return err
}
items, err := rd.ReadListStruct(2, false, func() taf.Unmarshaler { return &UserPrizeInfo{} })
if err != nil {
return err
}
r.Records = make([]UserPrizeInfo, 0, len(items))
for _, item := range items {
if record, ok := item.(*UserPrizeInfo); ok {
r.Records = append(r.Records, *record)
}
}
return nil
}
type ScoreExchangePrizeReq struct {
User ActivityUserID
SID int32
PID int32
IP string
ClientEnv map[string]string
Source string
IsRole int32
}
func (q *ScoreExchangePrizeReq) WriteTo(w *taf.Writer) error {
if err := w.WriteStruct(0, &q.User); err != nil {
return err
}
if err := w.WriteInt32(1, int64(q.SID)); err != nil {
return err
}
if err := w.WriteInt32(2, int64(q.PID)); err != nil {
return err
}
if err := w.WriteString(3, q.IP); err != nil {
return err
}
if err := w.WriteMapStringString(4, q.ClientEnv); err != nil {
return err
}
if err := w.WriteString(5, q.Source); err != nil {
return err
}
if q.IsRole == 0 {
q.IsRole = 1
}
return w.WriteInt32(6, int64(q.IsRole))
}
func (q *ScoreExchangePrizeReq) ReadFrom(r *taf.Reader) error {
_, err := r.ReadStruct(0, false, &q.User)
if err != nil {
return err
}
if q.SID, err = r.ReadInt32(1, false, q.SID); err != nil {
return err
}
if q.PID, err = r.ReadInt32(2, false, q.PID); err != nil {
return err
}
if q.IP, err = r.ReadString(3, false, q.IP); err != nil {
return err
}
if q.ClientEnv, err = r.ReadMapStringString(4, false); err != nil {
return err
}
if q.Source, err = r.ReadString(5, false, q.Source); err != nil {
return err
}
q.IsRole, err = r.ReadInt32(6, false, q.IsRole)
return err
}
type ExchangeInfo struct {
PID int32 `json:"pid"`
ExchangeScore int64 `json:"exchange_score"`
Desc string `json:"desc"`
}
func (e *ExchangeInfo) WriteTo(w *taf.Writer) error { return nil }
func (e *ExchangeInfo) ReadFrom(r *taf.Reader) error {
var err error
if e.PID, err = r.ReadInt32(1, false, e.PID); err != nil {
return err
}
if e.ExchangeScore, err = r.ReadInt64(2, false, e.ExchangeScore); err != nil {
return err
}
e.Desc, err = r.ReadString(3, false, e.Desc)
return err
}
type ActPreCondition struct {
ConditionType int32 `json:"condition_type"`
ConditionParams map[string]string `json:"condition_params,omitempty"`
Tip string `json:"tip,omitempty"`
JumpURL string `json:"jump_url,omitempty"`
ButtonDesc string `json:"button_desc,omitempty"`
}
func (c *ActPreCondition) WriteTo(w *taf.Writer) error { return nil }
func (c *ActPreCondition) ReadFrom(r *taf.Reader) error {
var err error
if c.ConditionType, err = r.ReadInt32(0, false, c.ConditionType); err != nil {
return err
}
if c.ConditionParams, err = r.ReadMapStringString(1, false); err != nil {
return err
}
if c.Tip, err = r.ReadString(2, false, c.Tip); err != nil {
return err
}
if c.JumpURL, err = r.ReadString(3, false, c.JumpURL); err != nil {
return err
}
c.ButtonDesc, err = r.ReadString(4, false, c.ButtonDesc)
return err
}
type ScoreExchangePrizeResp struct {
Status int32 `json:"status"`
Msg string `json:"msg"`
OrderID string `json:"order_id,omitempty"`
ExchangeInfo ExchangeInfo `json:"exchange_info"`
ActPreCondition ActPreCondition `json:"act_pre_condition"`
}
func (r *ScoreExchangePrizeResp) WriteTo(w *taf.Writer) error { return nil }
func (r *ScoreExchangePrizeResp) ReadFrom(rd *taf.Reader) error {
var err error
if r.Status, err = rd.ReadInt32(0, false, r.Status); err != nil {
return err
}
if r.Msg, err = rd.ReadString(1, false, r.Msg); err != nil {
return err
}
if r.OrderID, err = rd.ReadString(3, false, r.OrderID); err != nil {
return err
}
if _, err = rd.ReadStruct(4, false, &r.ExchangeInfo); err != nil {
return err
}
_, err = rd.ReadStruct(5, false, &r.ActPreCondition)
return err
}
func (r ScoreExchangePrizeResp) Success() bool {
return r.Status == 200 && (r.Msg == "" || strings.Contains(r.Msg, "成功"))
}
+101
View File
@@ -0,0 +1,101 @@
package huya
import (
"encoding/base64"
"math/rand"
"net/url"
"huya-go/internal/taf"
)
const (
HTTPHuyaUA = "webh5&0.0.1&websocket&&diypc_52775"
PCUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " +
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36"
)
type WSConnectParaInfo struct {
UID int64
GUID string
UA string
AppSrc string
MID string
Exp string
TokenType int32
Token string
Cookie string
TraceID string
CustomHeaders map[string]string
}
func NewWSConnectParaInfo(uid int64, guid, cookie string) WSConnectParaInfo {
return WSConnectParaInfo{
UID: uid,
GUID: guid,
UA: HTTPHuyaUA,
AppSrc: "HUYA&ZH&2052",
Cookie: cookie,
TraceID: NewTraceID(),
CustomHeaders: map[string]string{},
}
}
func (i WSConnectParaInfo) WriteTo(w *taf.Writer) error {
if err := w.WriteInt64(0, i.UID); err != nil {
return err
}
if err := w.WriteString(1, i.GUID); err != nil {
return err
}
if err := w.WriteString(2, i.UA); err != nil {
return err
}
if err := w.WriteString(3, i.AppSrc); err != nil {
return err
}
if err := w.WriteString(4, i.MID); err != nil {
return err
}
if err := w.WriteString(5, i.Exp); err != nil {
return err
}
if err := w.WriteInt32(6, int64(i.TokenType)); err != nil {
return err
}
if err := w.WriteString(7, i.Token); err != nil {
return err
}
if err := w.WriteString(8, i.Cookie); err != nil {
return err
}
if err := w.WriteString(9, i.TraceID); err != nil {
return err
}
return w.WriteMapStringString(10, i.CustomHeaders)
}
func NewTraceID() string {
// 与前端 traceId 格式保持一致:hex16:hex16:0:0。
v := rand.Uint64()
s := lowerHex16(v)
return s + ":" + s + ":0:0"
}
func lowerHex16(v uint64) string {
const digits = "0123456789abcdef"
var b [16]byte
for i := 15; i >= 0; i-- {
b[i] = digits[v&0xf]
v >>= 4
}
return string(b[:])
}
func GenerateHTTPBaseinfo(uid int64, guid, cookie string) (string, error) {
info := NewWSConnectParaInfo(uid, guid, cookie)
w := taf.NewWriter()
if err := info.WriteTo(w); err != nil {
return "", err
}
return url.QueryEscape(base64.StdEncoding.EncodeToString(w.Bytes())), nil
}
+39
View File
@@ -0,0 +1,39 @@
package huya
import (
"context"
"fmt"
"strings"
"time"
)
// ActivityClient 抽象虎牙活动接口,HTTP 与 WSS 传输都实现它。
type ActivityClient interface {
GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error)
QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error)
GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error)
ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error)
}
// NewActivityClient 按传输层创建活动客户端,供 CLI 和 GUI 共用。
func NewActivityClient(transport, wssHost string, timeout time.Duration, logger func(string)) (ActivityClient, func(), error) {
switch strings.ToLower(strings.TrimSpace(transport)) {
case "", "http":
client := NewHTTPClient(logger)
if timeout > 0 {
client.Client.Timeout = timeout
}
return client, func() {}, nil
case "wss", "ws", "websocket":
client := NewWSSClient(logger)
if strings.TrimSpace(wssHost) != "" {
client.Host = strings.TrimSpace(wssHost)
}
if timeout > 0 {
client.CallTimeout = timeout
}
return client, func() { _ = client.Close() }, nil
default:
return nil, func() {}, fmt.Errorf("未知传输层: %s", transport)
}
}
+70
View File
@@ -0,0 +1,70 @@
package huya
import (
"strconv"
"strings"
)
type CookiePair struct {
Key string
Value string
}
func CookiePairs(cookie string) []CookiePair {
parts := strings.Split(cookie, ";")
pairs := make([]CookiePair, 0, len(parts))
for _, part := range parts {
item := strings.TrimSpace(part)
if item == "" || !strings.Contains(item, "=") {
continue
}
key, value, _ := strings.Cut(item, "=")
key = strings.TrimSpace(key)
if key == "" {
continue
}
pairs = append(pairs, CookiePair{Key: key, Value: strings.TrimSpace(value)})
}
return pairs
}
func NormalizeCookie(cookie string) string {
pairs := CookiePairs(cookie)
order := make([]string, 0, len(pairs))
values := map[string]string{}
for _, pair := range pairs {
if _, ok := values[pair.Key]; !ok {
order = append(order, pair.Key)
}
values[pair.Key] = pair.Value
}
out := make([]string, 0, len(order))
for _, key := range order {
out = append(out, key+"="+values[key])
}
return strings.Join(out, "; ")
}
func CookieValue(cookie, key string) string {
value := ""
for _, pair := range CookiePairs(cookie) {
if pair.Key == key {
value = pair.Value
}
}
return value
}
func ResolveUID(cookie string) int64 {
for _, key := range []string{"yyuid", "udb_uid", "uid"} {
value := CookieValue(cookie, key)
if value == "" {
continue
}
uid, err := strconv.ParseInt(value, 10, 64)
if err == nil && uid > 0 {
return uid
}
}
return 0
}
+170
View File
@@ -0,0 +1,170 @@
package huya
import (
"bytes"
"compress/gzip"
"context"
"fmt"
"io"
"net/http"
"time"
"huya-go/internal/taf"
"huya-go/internal/wup"
)
const DefaultCDNWSEndpoint = "https://cdnws.api.huya.com/"
type HTTPClient struct {
Endpoint string
Client *http.Client
Logger func(string)
}
type CallOptions struct {
UID int64
GUID string
Cookie string
RequestID int32
Timeout time.Duration
}
func NewHTTPClient(logger func(string)) *HTTPClient {
return &HTTPClient{
Endpoint: DefaultCDNWSEndpoint,
Client: &http.Client{
Timeout: 15 * time.Second,
},
Logger: logger,
}
}
func (c *HTTPClient) logf(format string, args ...any) {
if c.Logger != nil {
c.Logger(fmt.Sprintf(format, args...))
}
}
func (c *HTTPClient) CallRPC(ctx context.Context, service, method string, reqStruct taf.Marshaler, respStruct taf.Unmarshaler, opt CallOptions) (*wup.Response, error) {
if opt.RequestID == 0 {
opt.RequestID = 1
}
reqWup := wup.NewRequest(service, method, opt.RequestID)
if err := reqWup.WriteStruct("tReq", reqStruct); err != nil {
return nil, err
}
body, err := reqWup.Encode()
if err != nil {
return nil, err
}
baseinfo, err := GenerateHTTPBaseinfo(opt.UID, opt.GUID, opt.Cookie)
if err != nil {
return nil, err
}
endpoint := c.Endpoint
if endpoint == "" {
endpoint = DefaultCDNWSEndpoint
}
url := endpoint + "?baseinfo=" + baseinfo
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
if err != nil {
return nil, err
}
httpReq.Header.Set("User-Agent", PCUserAgent)
httpReq.Header.Set("Origin", "https://zt.huya.com")
httpReq.Header.Set("Referer", "https://zt.huya.com/")
httpReq.Header.Set("Content-Type", "application/octet-stream")
httpReq.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
client := c.Client
if client == nil {
client = http.DefaultClient
}
if opt.Timeout > 0 {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, opt.Timeout)
defer cancel()
httpReq = httpReq.WithContext(ctx)
}
c.logf("[HTTP] POST %s.%s body=%dB", service, method, len(body))
httpResp, err := client.Do(httpReq)
if err != nil {
return nil, err
}
defer httpResp.Body.Close()
respBody, err := io.ReadAll(httpResp.Body)
if err != nil {
return nil, err
}
if len(respBody) >= 2 && respBody[0] == 0x1f && respBody[1] == 0x8b {
gz, err := gzip.NewReader(bytes.NewReader(respBody))
if err != nil {
return nil, err
}
respBody, err = io.ReadAll(gz)
_ = gz.Close()
if err != nil {
return nil, err
}
}
if httpResp.StatusCode < 200 || httpResp.StatusCode >= 300 {
return nil, fmt.Errorf("http status %d: %s", httpResp.StatusCode, string(respBody[:min(len(respBody), 200)]))
}
var resp wup.Response
if err := resp.Decode(respBody); err != nil {
return nil, err
}
if respStruct != nil {
ok, err := resp.ReadStruct("tRsp", respStruct)
if err != nil {
return nil, err
}
if !ok {
return nil, fmt.Errorf("%s.%s 响应缺少 tRsp/tResp", service, method)
}
}
return &resp, nil
}
func (c *HTTPClient) buildUser(uid int64, cookie, ua string) ActivityUserID {
return NewActivityUserID(uid, cookie, ua)
}
func (c *HTTPClient) QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) {
req := &GetUserScoreReq{User: c.buildUser(uid, cookie, ActivityWebUA), SID: sid}
var resp GetUserScoreResp
_, err := c.CallRPC(ctx, ServantWebActUI, FuncGetUserScore, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 2})
return &resp, err
}
func (c *HTTPClient) GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) {
req := &GetActPrizeListReq{User: c.buildUser(uid, cookie, ActivityWebUA), SID: sid}
var resp GetActPrizeListResp
_, err := c.CallRPC(ctx, ServantWebActUI, FuncPrizeList, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 1})
return &resp, err
}
func (c *HTTPClient) GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) {
user := c.buildUser(uid, cookie, ActivityRecordUA)
user.GUID = CookieValue(cookie, "guid")
req := &GetUserPrizeRecordsReq{User: user, SID: sid}
var resp GetUserPrizeRecordsResp
_, err := c.CallRPC(ctx, ServantWebActUI, FuncPrizeRecords, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 6})
return &resp, err
}
func (c *HTTPClient) ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) {
req := &ScoreExchangePrizeReq{
User: c.buildUser(uid, cookie, ActivityWebUA),
SID: sid,
PID: pid,
ClientEnv: map[string]string{},
IsRole: 1,
}
var resp ScoreExchangePrizeResp
_, err := c.CallRPC(ctx, ServantWebActUI, FuncExchangePrize, req, &resp, CallOptions{UID: uid, Cookie: cookie, RequestID: 1})
return &resp, err
}
+674
View File
@@ -0,0 +1,674 @@
package huya
import (
"context"
"errors"
"fmt"
"net/http"
"net/url"
"strconv"
"strings"
"sync"
"time"
"github.com/gorilla/websocket"
"huya-go/internal/taf"
"huya-go/internal/wup"
)
const (
DefaultWSSHost = "77bc035c-ws.va.huya.com"
DefaultWSSOrigin = "https://zt.huya.com"
WSSCookieUA = "webh5&0.0.1&websocket&&diypc_52775"
WSSBizUA = "web&1.0.0&huya"
WSSInitUA = "webh5&0.0.1&websocket&&h5_/index.html"
)
type WSSClient struct {
Host string
Origin string
UserAgent string
Dialer *websocket.Dialer
Logger func(string)
CallTimeout time.Duration
mu sync.Mutex
sessions map[string]*WSSSession
}
type WSSSession struct {
client *WSSClient
uid int64
cookie string
guid string
conn *websocket.Conn
writeMu sync.Mutex
pendingMu sync.Mutex
pending []chan rpcResult
closed chan struct{}
closeOnce sync.Once
closeErr error
nextWUPRequestID int32
launchGUID string
launchIP string
}
type rpcResult struct {
body []byte
err error
}
func NewWSSClient(logger func(string)) *WSSClient {
return &WSSClient{
Host: DefaultWSSHost,
Origin: DefaultWSSOrigin,
UserAgent: PCUserAgent,
Logger: logger,
CallTimeout: 10 * time.Second,
sessions: map[string]*WSSSession{},
}
}
func (c *WSSClient) logf(format string, args ...any) {
if c.Logger != nil {
c.Logger(fmt.Sprintf(format, args...))
}
}
func (c *WSSClient) Close() error {
c.mu.Lock()
sessions := make([]*WSSSession, 0, len(c.sessions))
for _, session := range c.sessions {
sessions = append(sessions, session)
}
c.sessions = map[string]*WSSSession{}
c.mu.Unlock()
var firstErr error
for _, session := range sessions {
if err := session.Close(); err != nil && firstErr == nil {
firstErr = err
}
}
return firstErr
}
func (c *WSSClient) session(ctx context.Context, uid int64, cookie string) (*WSSSession, error) {
key := strconv.FormatInt(uid, 10)
c.mu.Lock()
if session := c.sessions[key]; session != nil && !session.isClosed() {
c.mu.Unlock()
return session, nil
}
c.mu.Unlock()
c.mu.Lock()
defer c.mu.Unlock()
if session := c.sessions[key]; session != nil && !session.isClosed() {
return session, nil
}
session, err := c.dialSession(ctx, uid, cookie)
if err != nil {
return nil, err
}
c.sessions[key] = session
return session, nil
}
func (c *WSSClient) dialSession(ctx context.Context, uid int64, cookie string) (*WSSSession, error) {
host := c.Host
if host == "" {
host = DefaultWSSHost
}
origin := c.Origin
if origin == "" {
origin = DefaultWSSOrigin
}
userAgent := c.UserAgent
if userAgent == "" {
userAgent = PCUserAgent
}
guid := CookieValue(cookie, "guid")
baseinfo, err := GenerateHTTPBaseinfo(uid, guid, NormalizeWSSCookie(cookie))
if err != nil {
return nil, err
}
wsURL := url.URL{Scheme: "wss", Host: host, Path: "/"}
wsURL.RawQuery = "baseinfo=" + baseinfo
dialer := c.Dialer
if dialer == nil {
dialer = &websocket.Dialer{
HandshakeTimeout: 10 * time.Second,
EnableCompression: true,
Proxy: http.ProxyFromEnvironment,
}
}
headers := http.Header{}
headers.Set("Origin", origin)
headers.Set("User-Agent", userAgent)
headers.Set("Accept-Language", "zh-CN,zh;q=0.9")
c.logf("[WSS] 连接 %s uid=%d", host, uid)
conn, resp, err := dialer.DialContext(ctx, wsURL.String(), headers)
if err != nil {
if resp != nil {
return nil, fmt.Errorf("wss dial: %w (status=%s)", err, resp.Status)
}
return nil, fmt.Errorf("wss dial: %w", err)
}
conn.EnableWriteCompression(true)
conn.SetReadLimit(4 << 20)
session := &WSSSession{
client: c,
uid: uid,
cookie: cookie,
guid: guid,
conn: conn,
closed: make(chan struct{}),
nextWUPRequestID: 8,
}
go session.readLoop()
go session.heartbeatLoop()
if err := session.initialize(ctx); err != nil {
_ = session.Close()
return nil, err
}
return session, nil
}
func (s *WSSSession) isClosed() bool {
select {
case <-s.closed:
return true
default:
return false
}
}
func (s *WSSSession) Close() error {
var err error
s.closeOnce.Do(func() {
close(s.closed)
err = s.conn.Close()
s.failPending(errors.New("wss closed"))
})
return err
}
func (s *WSSSession) readLoop() {
for {
messageType, raw, err := s.conn.ReadMessage()
if err != nil {
s.closeWithError(err)
return
}
if messageType != websocket.BinaryMessage {
continue
}
msg, err := DecodeWSSMessage(raw)
if err != nil {
s.client.logf("[WSS] 解码消息失败: %v", err)
continue
}
switch msg.Command {
case WSSCommandRPCResponse:
s.resolveNext(rpcResult{body: msg.Body})
case WSSCommandHeartbeatRecv:
// 心跳响应无需处理。
default:
s.client.logf("[WSS] 收到 cmd=0x%02x seq=0x%08x body=%dB", msg.Command, msg.Sequence, len(msg.Body))
}
}
}
func (s *WSSSession) heartbeatLoop() {
ticker := time.NewTicker(8 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
_ = s.sendHeartbeat(ctx)
cancel()
case <-s.closed:
return
}
}
}
func (s *WSSSession) closeWithError(err error) {
s.closeOnce.Do(func() {
s.closeErr = err
close(s.closed)
_ = s.conn.Close()
s.failPending(err)
})
}
func (s *WSSSession) failPending(err error) {
s.pendingMu.Lock()
pending := s.pending
s.pending = nil
s.pendingMu.Unlock()
for _, ch := range pending {
ch <- rpcResult{err: err}
}
}
func (s *WSSSession) resolveNext(result rpcResult) {
s.pendingMu.Lock()
if len(s.pending) == 0 {
s.pendingMu.Unlock()
return
}
ch := s.pending[0]
copy(s.pending, s.pending[1:])
s.pending = s.pending[:len(s.pending)-1]
s.pendingMu.Unlock()
ch <- result
}
func (s *WSSSession) removePending(target chan rpcResult) {
s.pendingMu.Lock()
defer s.pendingMu.Unlock()
for i, ch := range s.pending {
if ch == target {
copy(s.pending[i:], s.pending[i+1:])
s.pending = s.pending[:len(s.pending)-1]
return
}
}
}
func (s *WSSSession) writeMessage(ctx context.Context, msg WSSMessage) error {
s.writeMu.Lock()
defer s.writeMu.Unlock()
if deadline, ok := ctx.Deadline(); ok {
_ = s.conn.SetWriteDeadline(deadline)
defer s.conn.SetWriteDeadline(time.Time{})
}
return s.conn.WriteMessage(websocket.BinaryMessage, msg.Encode())
}
func (s *WSSSession) callRaw(ctx context.Context, msg WSSMessage) ([]byte, error) {
ch := make(chan rpcResult, 1)
s.pendingMu.Lock()
s.pending = append(s.pending, ch)
s.pendingMu.Unlock()
if err := s.writeMessage(ctx, msg); err != nil {
s.removePending(ch)
return nil, err
}
select {
case result := <-ch:
return result.body, result.err
case <-ctx.Done():
s.removePending(ch)
return nil, ctx.Err()
case <-s.closed:
if s.closeErr != nil {
return nil, s.closeErr
}
return nil, errors.New("wss closed")
}
}
func (s *WSSSession) initialize(ctx context.Context) error {
if err := s.sendHeartbeat(ctx); err != nil {
return err
}
if err := s.callWSLaunch(ctx); err != nil {
return err
}
if err := s.callGetConfig(ctx); err != nil {
s.client.logf("[WSS] getConfig 失败但继续: %v", err)
}
if s.launchGUID != "" {
if err := s.sendRegister(ctx, s.launchGUID); err != nil {
return err
}
}
return s.sendConfirm(ctx)
}
func (s *WSSSession) withTimeout(ctx context.Context) (context.Context, context.CancelFunc) {
if _, ok := ctx.Deadline(); ok || s.client.CallTimeout <= 0 {
return ctx, func() {}
}
return context.WithTimeout(ctx, s.client.CallTimeout)
}
func (s *WSSSession) sendHeartbeat(ctx context.Context) error {
w := taf.NewWriter()
if err := w.WriteHead(0, taf.TypeList); err != nil {
return err
}
if err := w.WriteInt32(0, 1); err != nil {
return err
}
if err := w.WriteString(0, "live:0"); err != nil {
return err
}
if err := w.WriteString(1, ""); err != nil {
return err
}
body := append(append([]byte{}, w.Bytes()...), wssTailBytes...)
return s.writeMessage(ctx, WSSMessage{Command: WSSCommandHeartbeatSend, Sequence: wssSeqHeartbeat, Body: body})
}
func (s *WSSSession) callWSLaunch(ctx context.Context) error {
req := &wsLaunchReq{}
wupReq := wup.NewRequest("launch", "wsLaunch", -1)
wupReq.Timeout = 0
if err := wupReq.WriteStruct("tReq", req); err != nil {
return err
}
data, err := wupReq.Encode()
if err != nil {
return err
}
ctx, cancel := s.withTimeout(ctx)
defer cancel()
body, err := s.callRaw(ctx, WSSMessage{
Command: WSSCommandRPCRequest,
Sequence: wssSeqWSLaunch,
Body: encodeWSSRPCBody(data),
})
if err != nil {
return err
}
var resp wup.Response
if err := resp.Decode(extractWUPFromWSSBody(body)); err != nil {
return err
}
var launch wsLaunchResp
ok, err := resp.ReadStruct("tRsp", &launch)
if err != nil {
return err
}
if !ok {
return errors.New("wsLaunch 响应缺少 tRsp")
}
s.launchGUID = launch.GUID
s.launchIP = launch.ClientIP
s.client.logf("[WSS] wsLaunch guid=%s ip=%s", launch.GUID, launch.ClientIP)
return nil
}
func (s *WSSSession) callGetConfig(ctx context.Context) error {
req := &getConfigReq{}
wupReq := wup.NewRequest("mobileui", "getConfig", 7)
wupReq.Timeout = 0
if err := wupReq.WriteStruct("tReq", req); err != nil {
return err
}
data, err := wupReq.Encode()
if err != nil {
return err
}
ctx, cancel := s.withTimeout(ctx)
defer cancel()
_, err = s.callRaw(ctx, WSSMessage{
Command: WSSCommandRPCRequest,
Sequence: wssSeqGetConfig,
Body: encodeWSSRPCBody(data),
})
return err
}
func (s *WSSSession) sendRegister(ctx context.Context, launchGUID string) error {
w := taf.NewWriter()
if err := w.WriteString(0, "HUYA&ZH&2052"); err != nil {
return err
}
if err := w.WriteString(1, launchGUID); err != nil {
return err
}
if err := w.WriteInt32(2, 0); err != nil {
return err
}
if err := w.WriteInt32(3, 0); err != nil {
return err
}
if err := w.WriteStructBegin(6); err != nil {
return err
}
if err := w.WriteMapStringString(0, nil); err != nil {
return err
}
if err := w.WriteMapStringString(1, nil); err != nil {
return err
}
if err := w.WriteInt32(3, 0); err != nil {
return err
}
if err := w.WriteStructEnd(); err != nil {
return err
}
if err := w.WriteMapStringString(7, nil); err != nil {
return err
}
if err := w.WriteInt32(8, 0); err != nil {
return err
}
body := append(append([]byte{}, w.Bytes()...), wssTailBytes...)
return s.writeMessage(ctx, WSSMessage{Command: WSSCommandRegister, Sequence: wssSeqRegister, Body: body})
}
func (s *WSSSession) sendConfirm(ctx context.Context) error {
w := taf.NewWriter()
if err := w.WriteMapStringString(0, nil); err != nil {
return err
}
body := append(append([]byte{}, w.Bytes()...), wssTailBytes...)
return s.writeMessage(ctx, WSSMessage{Command: WSSCommandConfirmSend, Sequence: wssSeqConfirm, Body: body})
}
func (s *WSSSession) nextRequestID() int32 {
id := s.nextWUPRequestID
s.nextWUPRequestID++
return id
}
func (s *WSSSession) callRPC(ctx context.Context, service, method string, reqStruct taf.Marshaler, respStruct taf.Unmarshaler) (*wup.Response, error) {
wupReq := wup.NewRequest(service, method, s.nextRequestID())
wupReq.Timeout = 0
if err := wupReq.WriteStruct("tReq", reqStruct); err != nil {
return nil, err
}
data, err := wupReq.Encode()
if err != nil {
return nil, err
}
ctx, cancel := s.withTimeout(ctx)
defer cancel()
s.client.logf("[WSS] RPC %s.%s body=%dB", service, method, len(data))
body, err := s.callRaw(ctx, WSSMessage{
Command: WSSCommandRPCRequest,
Sequence: wssSeqBusiness,
Body: encodeWSSRPCBody(data),
})
if err != nil {
return nil, err
}
var resp wup.Response
if err := resp.Decode(extractWUPFromWSSBody(body)); err != nil {
return nil, err
}
if respStruct != nil {
ok, err := resp.ReadStruct("tRsp", respStruct)
if err != nil {
return nil, err
}
if !ok {
return nil, fmt.Errorf("%s.%s 响应缺少 tRsp/tResp", service, method)
}
}
return &resp, nil
}
func (c *WSSClient) buildUser(uid int64, cookie string) ActivityUserID {
user := NewActivityUserID(uid, NormalizeWSSCookie(cookie), WSSBizUA)
user.GUID = ""
user.Token = ""
user.DeviceInfo = ""
return user
}
func (c *WSSClient) QueryUserScore(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserScoreResp, error) {
session, err := c.session(ctx, uid, cookie)
if err != nil {
return nil, err
}
req := &GetUserScoreReq{User: c.buildUser(uid, cookie), SID: sid}
var resp GetUserScoreResp
_, err = session.callRPC(ctx, ServantWebActUI, FuncGetUserScore, req, &resp)
return &resp, err
}
func (c *WSSClient) GetActPrizeList(ctx context.Context, uid int64, cookie string, sid int32) (*GetActPrizeListResp, error) {
session, err := c.session(ctx, uid, cookie)
if err != nil {
return nil, err
}
req := &GetActPrizeListReq{User: c.buildUser(uid, cookie), SID: sid}
var resp GetActPrizeListResp
_, err = session.callRPC(ctx, ServantWebActUI, FuncPrizeList, req, &resp)
return &resp, err
}
func (c *WSSClient) GetUserPrizeRecords(ctx context.Context, uid int64, cookie string, sid int32) (*GetUserPrizeRecordsResp, error) {
session, err := c.session(ctx, uid, cookie)
if err != nil {
return nil, err
}
req := &GetUserPrizeRecordsReq{User: c.buildUser(uid, cookie), SID: sid}
var resp GetUserPrizeRecordsResp
_, err = session.callRPC(ctx, ServantWebActUI, FuncPrizeRecords, req, &resp)
return &resp, err
}
func (c *WSSClient) ScoreExchangePrize(ctx context.Context, uid int64, cookie string, sid, pid int32) (*ScoreExchangePrizeResp, error) {
session, err := c.session(ctx, uid, cookie)
if err != nil {
return nil, err
}
req := &ScoreExchangePrizeReq{
User: c.buildUser(uid, cookie),
SID: sid,
PID: pid,
ClientEnv: map[string]string{},
IsRole: 1,
}
var resp ScoreExchangePrizeResp
_, err = session.callRPC(ctx, ServantWebActUI, FuncExchangePrize, req, &resp)
return &resp, err
}
func NormalizeWSSCookie(cookie string) string {
cookie = NormalizeCookie(cookie)
pairs := CookiePairs(cookie)
out := []string{"huya_ua=" + WSSCookieUA}
for _, pair := range pairs {
if strings.EqualFold(pair.Key, "huya_ua") {
continue
}
out = append(out, pair.Key+"="+pair.Value)
}
return strings.Join(out, "; ")
}
type wsLaunchReq struct{}
func (r *wsLaunchReq) WriteTo(w *taf.Writer) error {
if err := w.WriteInt64(0, 0); err != nil {
return err
}
if err := w.WriteString(1, ""); err != nil {
return err
}
if err := w.WriteString(2, WSSInitUA); err != nil {
return err
}
if err := w.WriteString(3, "HUYA&ZH&2052"); err != nil {
return err
}
if err := w.WriteStructBegin(4); err != nil {
return err
}
for i := 0; i < 5; i++ {
if err := w.WriteString(i, ""); err != nil {
return err
}
}
return w.WriteStructEnd()
}
type wsLaunchResp struct {
GUID string
ClientIP string
}
func (r *wsLaunchResp) ReadFrom(rd *taf.Reader) error {
var err error
if r.GUID, err = rd.ReadString(0, false, r.GUID); err != nil {
return err
}
r.ClientIP, err = rd.ReadString(1, false, r.ClientIP)
return err
}
type getConfigReq struct{}
func (r *getConfigReq) WriteTo(w *taf.Writer) error {
if err := w.WriteStructBegin(0); err != nil {
return err
}
if err := w.WriteInt64(0, 0); err != nil {
return err
}
if err := w.WriteString(1, ""); err != nil {
return err
}
if err := w.WriteString(2, ""); err != nil {
return err
}
if err := w.WriteString(3, WSSInitUA); err != nil {
return err
}
if err := w.WriteString(4, ""); err != nil {
return err
}
if err := w.WriteInt32(5, 0); err != nil {
return err
}
if err := w.WriteString(6, ""); err != nil {
return err
}
if err := w.WriteString(7, ""); err != nil {
return err
}
if err := w.WriteStructEnd(); err != nil {
return err
}
if err := w.WriteMapStringString(1, nil); err != nil {
return err
}
if err := w.WriteString(2, "huya"); err != nil {
return err
}
if err := w.WriteHead(3, taf.TypeList); err != nil {
return err
}
return w.WriteInt32(0, 0)
}
+113
View File
@@ -0,0 +1,113 @@
package huya
import (
"encoding/binary"
"fmt"
"math/rand"
)
const (
WSSCommandRPCRequest byte = 0x03
WSSCommandRPCResponse byte = 0x04
WSSCommandAuth byte = 0x0a
WSSCommandHeartbeatSend byte = 0x10
WSSCommandHeartbeatRecv byte = 0x11
WSSCommandConfirmSend byte = 0x17
WSSCommandRegister byte = 0x21
wssSeqHeartbeat uint32 = 0x1d00000d
wssSeqWSLaunch uint32 = 0x1d000078
wssSeqGetConfig uint32 = 0x1d000076
wssSeqRegister uint32 = 0x1d00003c
wssSeqConfirm uint32 = 0x1d000002
wssSeqBusiness uint32 = 0x1d000106
)
var (
wssTailBytes = []byte{0x2c, 0x36, 0x00, 0x4c, 0x5c, 0x66, 0x00}
wssBigTailSuffix = []byte{0x4c, 0x5c, 0x66, 0x00}
)
// WSSMessage 是虎牙 WebSocketCommand 的 Go 表达。
//
// 外层格式来自浏览器/参考项目:
//
// 1B version(0) + 1B command + 4B sequence + body
type WSSMessage struct {
Command byte
Sequence uint32
Body []byte
}
func (m WSSMessage) Encode() []byte {
out := make([]byte, 6+len(m.Body))
out[0] = 0
out[1] = m.Command
binary.BigEndian.PutUint32(out[2:6], m.Sequence)
copy(out[6:], m.Body)
return out
}
func DecodeWSSMessage(data []byte) (WSSMessage, error) {
if len(data) < 6 {
return WSSMessage{}, fmt.Errorf("wss: 消息太短: %d", len(data))
}
return WSSMessage{
Command: data[1],
Sequence: binary.BigEndian.Uint32(data[2:6]),
Body: append([]byte(nil), data[6:]...),
}, nil
}
func encodeWSSRPCBody(wupData []byte) []byte {
if len(wupData) < 4 {
out := append([]byte{}, wupData...)
return append(out, wssTailBytes...)
}
declaredLen := int(binary.BigEndian.Uint32(wupData[:4]))
wupBody := wupData
if declaredLen == len(wupData) {
wupBody = wupData[4:]
}
if len(wupBody) <= 0xff {
out := append([]byte{}, wupData...)
return append(out, wssTailBytes...)
}
trace := NewWSSBigTailTrace()
packetLen := len(wupData)
out := make([]byte, 0, 1+4+len(wupBody)+len(trace))
out = append(out, byte(packetLen&0xff))
var lenBuf [4]byte
binary.BigEndian.PutUint32(lenBuf[:], uint32(packetLen))
out = append(out, lenBuf[:]...)
out = append(out, wupBody...)
out = append(out, trace...)
return out
}
func extractWUPFromWSSBody(body []byte) []byte {
if len(body) < 5 {
return body
}
// 大包格式: [1B prefix][4B wup_len][裸 WUP body][tail]
wupLen := int(binary.BigEndian.Uint32(body[1:5]))
if 5+wupLen <= len(body) && len(body) >= 7 && body[5] == 0x10 && body[6] == 0x03 {
return body[5 : 5+wupLen]
}
// 小包格式: [4B total_len][WUP body][tail]
totalLen := int(binary.BigEndian.Uint32(body[:4]))
if 8 <= totalLen && totalLen <= len(body) && body[4] == 0x10 && body[5] == 0x03 {
return body[:totalLen]
}
if 5+wupLen <= len(body) {
return body[5 : 5+wupLen]
}
return body
}
func NewWSSBigTailTrace() []byte {
trace := lowerHex16(rand.Uint64())
out := []byte(",6%" + trace + ":" + trace + ":0:3")
return append(out, wssBigTailSuffix...)
}
+130
View File
@@ -0,0 +1,130 @@
package sniper
import (
"context"
"strings"
"sync"
"time"
"huya-go/internal/huya"
)
type Account struct {
UID int64 `json:"uid"`
Cookie string `json:"-"`
}
type Target struct {
PID int32 `json:"pid"`
Name string `json:"name"`
}
type Config struct {
SID int32
Loops int
Delay time.Duration
Concurrency int
StopAfterSuccess bool
}
type Result struct {
Loop int `json:"loop"`
UID int64 `json:"uid"`
Action string `json:"action"`
Prize *huya.PrizeInfo `json:"prize,omitempty"`
Exchange *huya.ScoreExchangePrizeResp `json:"exchange,omitempty"`
Error string `json:"error,omitempty"`
}
type Runner struct {
Client huya.ActivityClient
}
func (r *Runner) Run(ctx context.Context, accounts []Account, target Target, cfg Config, emit func(Result)) error {
if cfg.Loops <= 0 {
cfg.Loops = 1
}
if cfg.Delay <= 0 {
cfg.Delay = 150 * time.Millisecond
}
if cfg.Concurrency <= 0 {
cfg.Concurrency = 1
}
var client huya.ActivityClient = r.Client
if client == nil {
client = huya.NewHTTPClient(nil)
}
ctx, cancel := context.WithCancel(ctx)
defer cancel()
for loop := 1; loop <= cfg.Loops; loop++ {
if ctx.Err() != nil {
return ctx.Err()
}
sem := make(chan struct{}, cfg.Concurrency)
var wg sync.WaitGroup
for _, account := range accounts {
account := account
wg.Add(1)
go func() {
defer wg.Done()
select {
case sem <- struct{}{}:
defer func() { <-sem }()
case <-ctx.Done():
return
}
result := r.tryAccount(ctx, client, account, target, cfg.SID, loop)
if emit != nil {
emit(result)
}
if cfg.StopAfterSuccess && result.Exchange != nil && result.Exchange.Success() {
cancel()
}
}()
}
wg.Wait()
if ctx.Err() != nil {
return ctx.Err()
}
if loop < cfg.Loops {
timer := time.NewTimer(cfg.Delay)
select {
case <-timer.C:
case <-ctx.Done():
timer.Stop()
return ctx.Err()
}
}
}
return nil
}
func (r *Runner) tryAccount(ctx context.Context, client huya.ActivityClient, account Account, target Target, sid int32, loop int) Result {
list, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, sid)
if err != nil {
return Result{Loop: loop, UID: account.UID, Action: "list_error", Error: err.Error()}
}
prize := matchPrize(list.Prizes, target)
if prize == nil {
return Result{Loop: loop, UID: account.UID, Action: "not_found"}
}
exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, int32(prize.ID))
if err != nil {
return Result{Loop: loop, UID: account.UID, Action: "exchange_error", Prize: prize, Error: err.Error()}
}
return Result{Loop: loop, UID: account.UID, Action: "exchange", Prize: prize, Exchange: exchange}
}
func matchPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo {
for i := range prizes {
if target.PID > 0 && int32(prizes[i].ID) == target.PID {
return &prizes[i]
}
if target.PID == 0 && target.Name != "" && strings.Contains(prizes[i].Name, target.Name) {
return &prizes[i]
}
}
return nil
}
+420
View File
@@ -0,0 +1,420 @@
package taf
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"io"
"math"
)
// Reader 负责从 TAF/JCE 字节流中按 tag 顺序读取字段。
type Reader struct {
buf *bytes.Reader
}
func NewReader(data []byte) *Reader {
return &Reader{buf: bytes.NewReader(data)}
}
func (r *Reader) Position() int64 {
pos, _ := r.buf.Seek(0, io.SeekCurrent)
return pos
}
func (r *Reader) Seek(pos int64) error {
_, err := r.buf.Seek(pos, io.SeekStart)
return err
}
func (r *Reader) ReadHead() (int, Type, error) {
b, err := r.buf.ReadByte()
if err != nil {
return 0, 0, err
}
tag := int((b >> 4) & 0x0f)
typ := Type(b & 0x0f)
if tag == 15 {
ext, err := r.buf.ReadByte()
if err != nil {
return 0, 0, err
}
tag = int(ext)
}
return tag, typ, nil
}
func (r *Reader) PeekHead() (int, Type, error) {
pos := r.Position()
tag, typ, err := r.ReadHead()
_ = r.Seek(pos)
return tag, typ, err
}
func (r *Reader) ReadIntValue(typ Type) (int64, error) {
switch typ {
case TypeZero:
return 0, nil
case TypeInt8:
b, err := r.buf.ReadByte()
return int64(int8(b)), err
case TypeInt16:
var b [2]byte
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
return 0, err
}
return int64(int16(binary.BigEndian.Uint16(b[:]))), nil
case TypeInt32:
var b [4]byte
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
return 0, err
}
return int64(int32(binary.BigEndian.Uint32(b[:]))), nil
case TypeInt64:
var b [8]byte
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
return 0, err
}
return int64(binary.BigEndian.Uint64(b[:])), nil
default:
return 0, fmt.Errorf("taf: 期望整数类型,实际 0x%02x", byte(typ))
}
}
func (r *Reader) ReadStringValue(typ Type) (string, error) {
var n uint32
switch typ {
case TypeString1:
b, err := r.buf.ReadByte()
if err != nil {
return "", err
}
n = uint32(b)
case TypeString4:
var b [4]byte
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
return "", err
}
n = binary.BigEndian.Uint32(b[:])
default:
return "", fmt.Errorf("taf: 期望字符串类型,实际 0x%02x", byte(typ))
}
raw := make([]byte, n)
if _, err := io.ReadFull(r.buf, raw); err != nil {
return "", err
}
return string(raw), nil
}
func (r *Reader) ReadBytesValue(typ Type) ([]byte, error) {
if typ != TypeSimpleList {
return nil, fmt.Errorf("taf: 期望 bytes,实际 0x%02x", byte(typ))
}
_, itemType, err := r.ReadHead()
if err != nil {
return nil, err
}
if itemType != TypeInt8 {
return nil, fmt.Errorf("taf: bytes 元素类型不是 int8: 0x%02x", byte(itemType))
}
n, err := r.readLength()
if err != nil {
return nil, err
}
if n < 0 || n > math.MaxInt32 {
return nil, fmt.Errorf("taf: bytes 长度异常: %d", n)
}
raw := make([]byte, int(n))
_, err = io.ReadFull(r.buf, raw)
return raw, err
}
func (r *Reader) Skip(typ Type) error {
switch typ {
case TypeZero:
return nil
case TypeInt8:
_, err := r.buf.ReadByte()
return err
case TypeInt16:
_, err := r.buf.Seek(2, io.SeekCurrent)
return err
case TypeInt32, TypeFloat:
_, err := r.buf.Seek(4, io.SeekCurrent)
return err
case TypeInt64, TypeDouble:
_, err := r.buf.Seek(8, io.SeekCurrent)
return err
case TypeString1:
b, err := r.buf.ReadByte()
if err != nil {
return err
}
_, err = r.buf.Seek(int64(b), io.SeekCurrent)
return err
case TypeString4:
var b [4]byte
if _, err := io.ReadFull(r.buf, b[:]); err != nil {
return err
}
_, err := r.buf.Seek(int64(binary.BigEndian.Uint32(b[:])), io.SeekCurrent)
return err
case TypeMap:
n, err := r.readLength()
if err != nil {
return err
}
for i := int64(0); i < n; i++ {
if _, kt, err := r.ReadHead(); err != nil {
return err
} else if err := r.Skip(kt); err != nil {
return err
}
if _, vt, err := r.ReadHead(); err != nil {
return err
} else if err := r.Skip(vt); err != nil {
return err
}
}
return nil
case TypeList:
n, err := r.readLength()
if err != nil {
return err
}
for i := int64(0); i < n; i++ {
if _, it, err := r.ReadHead(); err != nil {
return err
} else if err := r.Skip(it); err != nil {
return err
}
}
return nil
case TypeStructBegin:
return r.SkipToStructEnd()
case TypeStructEnd:
return nil
case TypeSimpleList:
_, itemType, err := r.ReadHead()
if err != nil {
return err
}
if itemType != TypeInt8 {
return fmt.Errorf("taf: simple list 元素类型异常: 0x%02x", byte(itemType))
}
n, err := r.readLength()
if err != nil {
return err
}
_, err = r.buf.Seek(n, io.SeekCurrent)
return err
default:
return fmt.Errorf("taf: 未知字段类型 0x%02x", byte(typ))
}
}
func (r *Reader) readLength() (int64, error) {
_, typ, err := r.ReadHead()
if err != nil {
return 0, err
}
return r.ReadIntValue(typ)
}
func (r *Reader) findTag(target int, required bool) (Type, bool, error) {
for {
pos := r.Position()
tag, typ, err := r.ReadHead()
if err != nil {
if errors.Is(err, io.EOF) && !required {
return 0, false, nil
}
return 0, false, err
}
if typ == TypeStructEnd {
_ = r.Seek(pos)
if required {
return 0, false, fmt.Errorf("taf: 未找到 tag=%d,已到结构尾", target)
}
return 0, false, nil
}
if tag == target {
return typ, true, nil
}
if tag > target {
_ = r.Seek(pos)
if required {
return 0, false, fmt.Errorf("taf: 未找到 tag=%d,遇到 tag=%d", target, tag)
}
return 0, false, nil
}
if err := r.Skip(typ); err != nil {
return 0, false, err
}
}
}
func (r *Reader) ReadInt64(tag int, required bool, def int64) (int64, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return def, err
}
return r.ReadIntValue(typ)
}
func (r *Reader) ReadInt32(tag int, required bool, def int32) (int32, error) {
value, err := r.ReadInt64(tag, required, int64(def))
return int32(value), err
}
func (r *Reader) ReadString(tag int, required bool, def string) (string, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return def, err
}
return r.ReadStringValue(typ)
}
func (r *Reader) ReadBytes(tag int, required bool, def []byte) ([]byte, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return def, err
}
return r.ReadBytesValue(typ)
}
func (r *Reader) ReadMapStringString(tag int, required bool) (map[string]string, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return map[string]string{}, err
}
if typ != TypeMap {
return nil, fmt.Errorf("taf: tag=%d 不是 map: 0x%02x", tag, byte(typ))
}
n, err := r.readLength()
if err != nil {
return nil, err
}
out := make(map[string]string, n)
for i := int64(0); i < n; i++ {
_, kt, err := r.ReadHead()
if err != nil {
return nil, err
}
k, err := r.ReadStringValue(kt)
if err != nil {
return nil, err
}
_, vt, err := r.ReadHead()
if err != nil {
return nil, err
}
v, err := r.ReadStringValue(vt)
if err != nil {
return nil, err
}
out[k] = v
}
return out, nil
}
func (r *Reader) ReadMapStringBytes(tag int, required bool) (map[string][]byte, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return map[string][]byte{}, err
}
if typ != TypeMap {
return nil, fmt.Errorf("taf: tag=%d 不是 map: 0x%02x", tag, byte(typ))
}
n, err := r.readLength()
if err != nil {
return nil, err
}
out := make(map[string][]byte, n)
for i := int64(0); i < n; i++ {
_, kt, err := r.ReadHead()
if err != nil {
return nil, err
}
k, err := r.ReadStringValue(kt)
if err != nil {
return nil, err
}
_, vt, err := r.ReadHead()
if err != nil {
return nil, err
}
v, err := r.ReadBytesValue(vt)
if err != nil {
return nil, err
}
out[k] = v
}
return out, nil
}
func (r *Reader) ReadStruct(tag int, required bool, obj Unmarshaler) (bool, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return false, err
}
if typ != TypeStructBegin {
return false, fmt.Errorf("taf: tag=%d 不是结构体: 0x%02x", tag, byte(typ))
}
if err := obj.ReadFrom(r); err != nil {
return false, err
}
return true, r.SkipToStructEnd()
}
func (r *Reader) ReadListStruct(tag int, required bool, factory func() Unmarshaler) ([]Unmarshaler, error) {
typ, ok, err := r.findTag(tag, required)
if err != nil || !ok {
return nil, err
}
if typ != TypeList {
return nil, fmt.Errorf("taf: tag=%d 不是 list: 0x%02x", tag, byte(typ))
}
n, err := r.readLength()
if err != nil {
return nil, err
}
out := make([]Unmarshaler, 0, n)
for i := int64(0); i < n; i++ {
_, it, err := r.ReadHead()
if err != nil {
return nil, err
}
if it != TypeStructBegin {
if err := r.Skip(it); err != nil {
return nil, err
}
continue
}
obj := factory()
if err := obj.ReadFrom(r); err != nil {
return nil, err
}
if err := r.SkipToStructEnd(); err != nil {
return nil, err
}
out = append(out, obj)
}
return out, nil
}
func (r *Reader) SkipToStructEnd() error {
for {
_, typ, err := r.ReadHead()
if err != nil {
return err
}
if typ == TypeStructEnd {
return nil
}
if err := r.Skip(typ); err != nil {
return err
}
}
}
+31
View File
@@ -0,0 +1,31 @@
package taf_test
import (
"testing"
"huya-go/internal/huya"
"huya-go/internal/taf"
)
func TestStructRoundTrip(t *testing.T) {
user := &huya.ActivityUserID{
UID: 123456,
GUID: "guid-1",
HuyaUA: huya.ActivityWebUA,
Cookie: "yyuid=123456;",
TokenType: 0,
}
w := taf.NewWriter()
if err := w.WriteStruct(0, user); err != nil {
t.Fatal(err)
}
var got huya.ActivityUserID
r := taf.NewReader(w.Bytes())
ok, err := r.ReadStruct(0, true, &got)
if err != nil {
t.Fatal(err)
}
if !ok || got.UID != user.UID || got.GUID != user.GUID || got.HuyaUA != user.HuyaUA {
t.Fatalf("round trip mismatch: %#v", got)
}
}
+31
View File
@@ -0,0 +1,31 @@
package taf
// Type 是虎牙前端使用的 TAF/JCE 字段类型。
type Type byte
const (
TypeInt8 Type = 0x00
TypeInt16 Type = 0x01
TypeInt32 Type = 0x02
TypeInt64 Type = 0x03
TypeFloat Type = 0x04
TypeDouble Type = 0x05
TypeString1 Type = 0x06
TypeString4 Type = 0x07
TypeMap Type = 0x08
TypeList Type = 0x09
TypeStructBegin Type = 0x0a
TypeStructEnd Type = 0x0b
TypeZero Type = 0x0c
TypeSimpleList Type = 0x0d
)
// Marshaler 表示可编码成 TAF 结构体字段的对象。
type Marshaler interface {
WriteTo(*Writer) error
}
// Unmarshaler 表示可从 TAF 结构体字段读取自身的对象。
type Unmarshaler interface {
ReadFrom(*Reader) error
}
+232
View File
@@ -0,0 +1,232 @@
package taf
import (
"bytes"
"encoding/binary"
"fmt"
"math"
)
// Writer 负责按 TAF/JCE 格式编码字段。
type Writer struct {
buf bytes.Buffer
}
func NewWriter() *Writer {
return &Writer{}
}
func (w *Writer) Bytes() []byte {
return w.buf.Bytes()
}
func (w *Writer) WriteHead(tag int, typ Type) error {
if tag < 0 || tag > 255 {
return fmt.Errorf("taf: tag 超出范围: %d", tag)
}
if tag < 15 {
return w.buf.WriteByte(byte(tag<<4) | byte(typ))
}
if err := w.buf.WriteByte(0xf0 | byte(typ)); err != nil {
return err
}
return w.buf.WriteByte(byte(tag))
}
func (w *Writer) WriteInt8(tag int, value int64) error {
if value == 0 {
return w.WriteHead(tag, TypeZero)
}
if value < math.MinInt8 || value > math.MaxInt8 {
return fmt.Errorf("taf: int8 溢出: %d", value)
}
if err := w.WriteHead(tag, TypeInt8); err != nil {
return err
}
return w.buf.WriteByte(byte(int8(value)))
}
func (w *Writer) WriteInt16(tag int, value int64) error {
if value >= math.MinInt8 && value <= math.MaxInt8 {
return w.WriteInt8(tag, value)
}
if value < math.MinInt16 || value > math.MaxInt16 {
return fmt.Errorf("taf: int16 溢出: %d", value)
}
if err := w.WriteHead(tag, TypeInt16); err != nil {
return err
}
var b [2]byte
binary.BigEndian.PutUint16(b[:], uint16(int16(value)))
_, err := w.buf.Write(b[:])
return err
}
func (w *Writer) WriteInt32(tag int, value int64) error {
if value >= math.MinInt16 && value <= math.MaxInt16 {
return w.WriteInt16(tag, value)
}
if value < math.MinInt32 || value > math.MaxInt32 {
return fmt.Errorf("taf: int32 溢出: %d", value)
}
if err := w.WriteHead(tag, TypeInt32); err != nil {
return err
}
var b [4]byte
binary.BigEndian.PutUint32(b[:], uint32(int32(value)))
_, err := w.buf.Write(b[:])
return err
}
func (w *Writer) WriteInt64(tag int, value int64) error {
if value >= math.MinInt32 && value <= math.MaxInt32 {
return w.WriteInt32(tag, value)
}
if err := w.WriteHead(tag, TypeInt64); err != nil {
return err
}
var b [8]byte
binary.BigEndian.PutUint64(b[:], uint64(value))
_, err := w.buf.Write(b[:])
return err
}
func (w *Writer) WriteBool(tag int, value bool) error {
if value {
return w.WriteInt8(tag, 1)
}
return w.WriteInt8(tag, 0)
}
func (w *Writer) WriteFloat(tag int, value float32) error {
if err := w.WriteHead(tag, TypeFloat); err != nil {
return err
}
var b [4]byte
binary.BigEndian.PutUint32(b[:], math.Float32bits(value))
_, err := w.buf.Write(b[:])
return err
}
func (w *Writer) WriteDouble(tag int, value float64) error {
if err := w.WriteHead(tag, TypeDouble); err != nil {
return err
}
var b [8]byte
binary.BigEndian.PutUint64(b[:], math.Float64bits(value))
_, err := w.buf.Write(b[:])
return err
}
func (w *Writer) WriteString(tag int, value string) error {
raw := []byte(value)
if len(raw) > math.MaxUint8 {
if err := w.WriteHead(tag, TypeString4); err != nil {
return err
}
var b [4]byte
binary.BigEndian.PutUint32(b[:], uint32(len(raw)))
if _, err := w.buf.Write(b[:]); err != nil {
return err
}
_, err := w.buf.Write(raw)
return err
}
if err := w.WriteHead(tag, TypeString1); err != nil {
return err
}
if err := w.buf.WriteByte(byte(len(raw))); err != nil {
return err
}
_, err := w.buf.Write(raw)
return err
}
func (w *Writer) WriteBytes(tag int, value []byte) error {
if err := w.WriteHead(tag, TypeSimpleList); err != nil {
return err
}
if err := w.WriteHead(0, TypeInt8); err != nil {
return err
}
if err := w.WriteInt32(0, int64(len(value))); err != nil {
return err
}
_, err := w.buf.Write(value)
return err
}
func (w *Writer) WriteStructBegin(tag int) error {
return w.WriteHead(tag, TypeStructBegin)
}
func (w *Writer) WriteStructEnd() error {
return w.WriteHead(0, TypeStructEnd)
}
func (w *Writer) WriteStruct(tag int, value Marshaler) error {
if err := w.WriteStructBegin(tag); err != nil {
return err
}
if err := value.WriteTo(w); err != nil {
return err
}
return w.WriteStructEnd()
}
func (w *Writer) WriteMapStringString(tag int, value map[string]string) error {
if value == nil {
value = map[string]string{}
}
if err := w.WriteHead(tag, TypeMap); err != nil {
return err
}
if err := w.WriteInt32(0, int64(len(value))); err != nil {
return err
}
for k, v := range value {
if err := w.WriteString(0, k); err != nil {
return err
}
if err := w.WriteString(1, v); err != nil {
return err
}
}
return nil
}
func (w *Writer) WriteMapStringBytes(tag int, value map[string][]byte) error {
if value == nil {
value = map[string][]byte{}
}
if err := w.WriteHead(tag, TypeMap); err != nil {
return err
}
if err := w.WriteInt32(0, int64(len(value))); err != nil {
return err
}
for k, v := range value {
if err := w.WriteString(0, k); err != nil {
return err
}
if err := w.WriteBytes(1, v); err != nil {
return err
}
}
return nil
}
func (w *Writer) WriteListStruct(tag int, values []Marshaler) error {
if err := w.WriteHead(tag, TypeList); err != nil {
return err
}
if err := w.WriteInt32(0, int64(len(values))); err != nil {
return err
}
for _, value := range values {
if err := w.WriteStruct(0, value); err != nil {
return err
}
}
return nil
}
+263
View File
@@ -0,0 +1,263 @@
package wup
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"io"
"huya-go/internal/taf"
)
// Request 是 WUP v3 请求封装。
type Request struct {
Version int16
PacketType int8
Message int32
RequestID int32
Servant string
Func string
Timeout int32
Context map[string]string
Status map[string]string
NewData map[string][]byte
}
func NewRequest(servant, fn string, requestID int32) *Request {
return &Request{
Version: 3,
Servant: servant,
Func: fn,
RequestID: requestID,
Timeout: 3000,
Context: map[string]string{},
Status: map[string]string{},
NewData: map[string][]byte{},
}
}
func (r *Request) WriteStruct(key string, value taf.Marshaler) error {
w := taf.NewWriter()
if err := w.WriteStruct(0, value); err != nil {
return err
}
r.NewData[key] = w.Bytes()
return nil
}
func (r *Request) Encode() ([]byte, error) {
data := taf.NewWriter()
if err := data.WriteMapStringBytes(0, r.NewData); err != nil {
return nil, err
}
body := taf.NewWriter()
if err := body.WriteInt16(1, int64(r.Version)); err != nil {
return nil, err
}
if err := body.WriteInt8(2, int64(r.PacketType)); err != nil {
return nil, err
}
if err := body.WriteInt32(3, int64(r.Message)); err != nil {
return nil, err
}
if err := body.WriteInt32(4, int64(r.RequestID)); err != nil {
return nil, err
}
if err := body.WriteString(5, r.Servant); err != nil {
return nil, err
}
if err := body.WriteString(6, r.Func); err != nil {
return nil, err
}
if err := body.WriteBytes(7, data.Bytes()); err != nil {
return nil, err
}
if err := body.WriteInt32(8, int64(r.Timeout)); err != nil {
return nil, err
}
if err := body.WriteMapStringString(9, r.Context); err != nil {
return nil, err
}
if err := body.WriteMapStringString(10, r.Status); err != nil {
return nil, err
}
rawBody := body.Bytes()
out := bytes.NewBuffer(make([]byte, 0, len(rawBody)+4))
var lenBuf [4]byte
binary.BigEndian.PutUint32(lenBuf[:], uint32(len(rawBody)+4))
out.Write(lenBuf[:])
out.Write(rawBody)
return out.Bytes(), nil
}
// Response 是 WUP 响应封装。
type Response struct {
Version int16
PacketType int8
Message int32
RequestID int32
Servant string
Func string
Buffer []byte
Timeout int32
Context map[string]string
Status map[string]string
NewData map[string][]byte
}
func (r *Response) Decode(data []byte) error {
body := NormalizePayload(data)
reader := taf.NewReader(body)
r.Context = map[string]string{}
r.Status = map[string]string{}
r.NewData = map[string][]byte{}
for {
tag, typ, err := reader.ReadHead()
if err != nil {
if errors.Is(err, io.EOF) {
return nil
}
return err
}
if tag > 10 {
return nil
}
switch tag {
case 1:
v, err := reader.ReadIntValue(typ)
r.Version = int16(v)
if err != nil {
return err
}
case 2:
v, err := reader.ReadIntValue(typ)
r.PacketType = int8(v)
if err != nil {
return err
}
case 3:
v, err := reader.ReadIntValue(typ)
r.Message = int32(v)
if err != nil {
return err
}
case 4:
v, err := reader.ReadIntValue(typ)
r.RequestID = int32(v)
if err != nil {
return err
}
case 5:
v, err := reader.ReadStringValue(typ)
r.Servant = v
if err != nil {
return err
}
case 6:
v, err := reader.ReadStringValue(typ)
r.Func = v
if err != nil {
return err
}
case 7:
v, err := reader.ReadBytesValue(typ)
if err != nil {
return err
}
r.Buffer = v
if err := r.decodeBuffer(); err != nil {
return err
}
case 8:
v, err := reader.ReadIntValue(typ)
r.Timeout = int32(v)
if err != nil {
return err
}
case 9:
if typ != taf.TypeMap {
if err := reader.Skip(typ); err != nil {
return err
}
continue
}
_ = reader.Seek(reader.Position() - 1)
v, err := reader.ReadMapStringString(9, false)
r.Context = v
if err != nil {
return err
}
case 10:
if typ != taf.TypeMap {
if err := reader.Skip(typ); err != nil {
return err
}
return nil
}
_ = reader.Seek(reader.Position() - 1)
v, err := reader.ReadMapStringString(10, false)
r.Status = v
if err != nil {
return err
}
return nil
default:
if err := reader.Skip(typ); err != nil {
return err
}
}
}
}
func (r *Response) decodeBuffer() error {
if len(r.Buffer) == 0 {
return nil
}
reader := taf.NewReader(r.Buffer)
m, err := reader.ReadMapStringBytes(0, false)
if err != nil {
return err
}
r.NewData = m
return nil
}
func (r *Response) ReadStruct(key string, obj taf.Unmarshaler) (bool, error) {
data := r.NewData[key]
if len(data) == 0 && key == "tRsp" {
data = r.NewData["tResp"]
}
if len(data) == 0 && key == "tResp" {
data = r.NewData["tRsp"]
}
if len(data) == 0 {
return false, nil
}
reader := taf.NewReader(data)
_, typ, err := reader.ReadHead()
if err != nil {
return false, err
}
if typ != taf.TypeStructBegin {
return false, fmt.Errorf("wup: %s 不是结构体响应: 0x%02x", key, byte(typ))
}
if err := obj.ReadFrom(reader); err != nil {
return false, err
}
return true, reader.SkipToStructEnd()
}
func NormalizePayload(data []byte) []byte {
if len(data) < 4 {
return data
}
n := int(binary.BigEndian.Uint32(data[:4]))
if n == len(data) || n+4 == len(data) {
return data[4:]
}
return data
}
+33
View File
@@ -0,0 +1,33 @@
package wup_test
import (
"testing"
"huya-go/internal/huya"
"huya-go/internal/wup"
)
func TestWupEncodeDecodeHeader(t *testing.T) {
req := wup.NewRequest(huya.ServantWebActUI, huya.FuncGetUserScore, 2)
err := req.WriteStruct("tReq", &huya.GetUserScoreReq{
User: huya.NewActivityUserID(123, "yyuid=123;", huya.ActivityWebUA),
SID: 456,
})
if err != nil {
t.Fatal(err)
}
raw, err := req.Encode()
if err != nil {
t.Fatal(err)
}
var resp wup.Response
if err := resp.Decode(raw); err != nil {
t.Fatal(err)
}
if resp.Servant != huya.ServantWebActUI || resp.Func != huya.FuncGetUserScore || resp.RequestID != 2 {
t.Fatalf("unexpected header: %#v", resp)
}
if len(resp.NewData["tReq"]) == 0 {
t.Fatal("missing tReq")
}
}