少前|-|{"files":{"gf.go":{"env":"plain"}},"tag":"Github"}

gf.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"net/http/cookiejar"
	"strconv"
	"strings"
	"time"

	"github.com/ihciah/GFHelper/cipher"
)

var timeStamp int64

const (
	userAgent = "Dalvik/2.1.0 (Linux; U; Android 6.0.1; ONEPLUS A3010 Build/MXB48T)"
)

func getTimeStamp() int64 {
	if timeStamp == 0 {
		timeStamp = time.Now().Unix()*100000 + 1
	} else {
		timeStamp += 1
	}
	return timeStamp
}

func setHeaders(header *http.Header, v map[string]string) {
	for key, value := range v {
		header.Set(key, value)
	}
}

type User struct {
	AppID         string        `json:"app_id"`
	LoginIdentify string        `json:"login_identify"`
	LoginPwd      string        `json:"login_pwd"`
	ChannelId     string        `json:"channel_id"`
	NbUid         NbUid         `json:"-"`
	AuthInfo      UserLoginInfo `json:"-"`
	StartID       int64         `json:"-"`
	Logger        *log.Logger   `json:"-"`
}

type UserLoginInfo struct {
	AccessToken  string `json:"access_token"`
	Result       int    `json:"result"`
	Msg          string `json:"msg"`
	Openid       string `json:"openid"`
	RegisterMode string `json:"register_mode"`
	State        int    `json:"state"`
	AppID        string `json:"app_id"`
}

type DigitalSkyNbUidInfo struct {
	Openid      string `json:"openid"`
	AccessToken string `json:"access_token"`
	AppID       string `json:"app_id"`
	ChannelID   string `json:"channel_id"`
	Idfa        string `json:"idfa"`
	AndroidID   string `json:"androidid"`
	Mac         string `json:"mac"`
	ReqID       string `json:"req_id"`
}

type NbUid struct {
	UID             string `json:"uid"`
	Sign            string `json:"sign"`
	IsUsernameExist bool   `json:"is_username_exist"`
	//RealName          int    `json:"real_name"`
	AuthenticationURL string `json:"authentication_url"`
	TcOrderRetry      int    `json:"tc_order_retry"`
}

func (u *User) NormalLogin(client *http.Client) {
	url := "http://gf.ucenter.ppgame.com/normal_login"
	frontData := `{"app_id":"0002000100021001","version":"1.0"}`
	backData, err := json.Marshal(u)
	if err != nil {
		log.Fatal(err)
	}
	encBackData := cipher.XXTEAEncrypt(backData)
	body := append([]byte(frontData), byte(0))
	body = append(body, encBackData...)

	rsp, err := client.Do(ConstructReq("POST", url, bytes.NewBuffer(body)))
	if err != nil {
		log.Fatal(err)
	}
	defer rsp.Body.Close()
	rspBody, err := ioutil.ReadAll(rsp.Body)
	if err != nil {
		log.Fatal(err)
	}
	err = json.Unmarshal(rspBody, &u.AuthInfo)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Normal Login succeed")
}

func KeyValueSPrintf(key, value string) string {
	return fmt.Sprintf("%s=%s", key, value)
}

func (u *User) GetSkyNbUid(client *http.Client) {
	url := "http://gf-adrgw-cn-zs-game-0001.ppgame.com/index.php/1000/Index/getDigitalSkyNbUid"

	var temp_body = []string{
		KeyValueSPrintf("openid", u.AuthInfo.Openid),
		KeyValueSPrintf("access_token", u.AuthInfo.AccessToken),
		KeyValueSPrintf("app_id", u.AppID),
		KeyValueSPrintf("channel_id", u.ChannelId),
		KeyValueSPrintf("idfa", ""),
		KeyValueSPrintf("androidid", ""),
		KeyValueSPrintf("mac", "02-00-00-00-00-00"),
		KeyValueSPrintf("req_id", strconv.FormatInt(getTimeStamp(), 10)),
	}

	body := strings.Join(temp_body, "&")

	log.Printf("%s\n", string(body))

	req := ConstructReq("POST", url, bytes.NewBuffer([]byte(body)))

	rsp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer rsp.Body.Close()
	rspBody, err := ioutil.ReadAll(rsp.Body)
	if err != nil || len(rspBody) == 0 {
		log.Fatal(err, "rspBody length 0")
	}

	if strings.HasPrefix(string(rspBody), "{") {
		log.Fatal(string(rspBody))
	}
	if rspBody[0] != byte('#') {
		log.Fatal("Rsp body not start with #")
	}

	jsonStr, err := cipher.AuthCodeDecodeB64(string(rspBody)[1:], "yundoudou", true)
	if err != nil {
		log.Fatal("Error when decrypting result.")
	}
	err = json.Unmarshal([]byte(jsonStr), &u.NbUid)
	if err != nil {
		log.Fatal("Error when unmarshaling to struct.")
	}
	log.Println("Got SkyNbUid.")
	log.Printf("SkyNbUid: %+v\n", u.NbUid)
}

type IndexInfo struct {
	Time int64 `json:"time"`
}

func (u *User) Index(client *http.Client) bool {
	url := "http://gf-adrgw-cn-zs-game-0001.ppgame.com/index.php/1000/Index/index"

	out := IndexInfo{time.Now().Unix()}
	outdata, err := json.Marshal(out)
	log.Printf("outdata: %s\n", outdata)
	if err != nil {
		log.Fatal(err)
	}
	encOutData, err := cipher.AuthCodeEncodeB64(string(outdata), u.NbUid.Sign)
	if err != nil {
		log.Fatal(err)
	}
	tempdata := []string{
		KeyValueSPrintf("uid", u.NbUid.UID),
		KeyValueSPrintf("outdatacode", encOutData),
		KeyValueSPrintf("req_id", strconv.FormatInt(getTimeStamp(), 10)),
	}
	body := strings.Join(tempdata, "&")
	log.Println("body: ", body)
	req := ConstructReq("POST", url, bytes.NewBuffer([]byte(body)))
	rsp, err := client.Do(req)
	if err != nil {
		log.Fatal(rsp)
	}
	defer rsp.Body.Close()
	rspBody, err := ioutil.ReadAll(rsp.Body)
	if err != nil {
		log.Fatal(err)
	}
	if len(rspBody) == 0 {
		log.Fatal("len == 0")
	}
	if rspBody[0] != byte('#') {
		log.Printf("%s\n", rspBody)
		log.Println("body not start with #")
		return false
	}
	res, err := cipher.AuthCodeDecodeB64(string(rspBody[1:]), u.NbUid.Sign, true)
	log.Printf("Index data: %v\n", res)
	return true
}

func ConstructReq(method, url string, body io.Reader) *http.Request {
	req, err := http.NewRequest(method, url, body)
	if err != nil {
		log.Fatal(err)
	}
	setHeaders(&req.Header, map[string]string{
		"Accept-Encoding": "gzip, deflate",
		"Accept-Language": "zh-cn",
		"Content-Type":    "application/x-www-form-urlencoded",
		"User-Agent":      userAgent,
		"X-Unity-Version": "2017.4.21f1",
	})
	return req
}

func main() {
	jar, err := cookiejar.New(nil)
	if err != nil {
		log.Fatal(err)
	}
	client := http.Client{
		Jar: jar,
	}
	user := User{
		AppID:         "0002000100021001",
		LoginIdentify: "",
		LoginPwd:      cipher.MD5s(""),
		ChannelId:     "android",
	}
	user.NormalLogin(&client)

	user.GetSkyNbUid(&client)

	user.Index(&client)
}