138 lines
3.1 KiB
Go
138 lines
3.1 KiB
Go
package algos
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"strconv"
|
|
)
|
|
|
|
// Gorgon Gorgon加密器
|
|
type Gorgon struct {
|
|
unix int64
|
|
params string
|
|
xSSStub string
|
|
cookies string
|
|
}
|
|
|
|
// NewGorgon 创建新的Gorgon实例
|
|
func NewGorgon(params string, unix int64, xSSStub string, cookies string) *Gorgon {
|
|
if xSSStub == "" {
|
|
xSSStub = "00000000000000000000000000000000"
|
|
}
|
|
return &Gorgon{
|
|
unix: unix,
|
|
params: params,
|
|
xSSStub: xSSStub,
|
|
cookies: cookies,
|
|
}
|
|
}
|
|
|
|
// hash MD5哈希
|
|
func (g *Gorgon) hash(data string) string {
|
|
hasher := md5.New()
|
|
hasher.Write([]byte(data))
|
|
return hex.EncodeToString(hasher.Sum(nil))
|
|
}
|
|
|
|
// getBaseString 获取基础字符串
|
|
func (g *Gorgon) getBaseString() string {
|
|
baseStr := g.hash(g.params)
|
|
baseStr = baseStr + g.xSSStub
|
|
|
|
if g.cookies != "" {
|
|
baseStr = baseStr + g.hash(g.cookies)
|
|
} else {
|
|
baseStr = baseStr + "00000000000000000000000000000000"
|
|
}
|
|
|
|
return baseStr
|
|
}
|
|
|
|
// rbitAlgorithm 位反转算法
|
|
func (g *Gorgon) rbitAlgorithm(num int) int {
|
|
result := ""
|
|
tmpString := fmt.Sprintf("%08b", num)
|
|
|
|
for i := 0; i < 8; i++ {
|
|
result = result + string(tmpString[7-i])
|
|
}
|
|
|
|
val, _ := strconv.ParseInt(result, 2, 64)
|
|
return int(val)
|
|
}
|
|
|
|
// hexString 转十六进制字符串
|
|
func (g *Gorgon) hexString(num int) string {
|
|
tmpString := fmt.Sprintf("%x", num)
|
|
if len(tmpString) < 2 {
|
|
tmpString = "0" + tmpString
|
|
}
|
|
return tmpString
|
|
}
|
|
|
|
// reverse 反转
|
|
func (g *Gorgon) reverse(num int) int {
|
|
tmpString := g.hexString(num)
|
|
val, _ := strconv.ParseInt(tmpString[1:]+tmpString[:1], 16, 64)
|
|
return int(val)
|
|
}
|
|
|
|
// encrypt 加密
|
|
func (g *Gorgon) encrypt(data string) map[string]string {
|
|
length := 0x14
|
|
key := []int{
|
|
0xDF, 0x77, 0xB9, 0x40, 0xB9, 0x9B, 0x84, 0x83,
|
|
0xD1, 0xB9, 0xCB, 0xD1, 0xF7, 0xC2, 0xB9, 0x85,
|
|
0xC3, 0xD0, 0xFB, 0xC3,
|
|
}
|
|
|
|
paramList := make([]int, 0)
|
|
for i := 0; i < 12; i += 4 {
|
|
temp := data[8*i : 8*(i+1)]
|
|
for j := 0; j < 4; j++ {
|
|
val, _ := strconv.ParseInt(temp[j*2:(j+1)*2], 16, 64)
|
|
paramList = append(paramList, int(val))
|
|
}
|
|
}
|
|
|
|
paramList = append(paramList, 0x0, 0x6, 0xB, 0x1C)
|
|
|
|
H := int(g.unix)
|
|
paramList = append(paramList, (H&0xFF000000)>>24)
|
|
paramList = append(paramList, (H&0x00FF0000)>>16)
|
|
paramList = append(paramList, (H&0x0000FF00)>>8)
|
|
paramList = append(paramList, (H&0x000000FF)>>0)
|
|
|
|
eorResultList := make([]int, len(paramList))
|
|
for i, val := range paramList {
|
|
eorResultList[i] = val ^ key[i]
|
|
}
|
|
|
|
for i := 0; i < length; i++ {
|
|
C := g.reverse(eorResultList[i])
|
|
D := eorResultList[(i+1)%length]
|
|
E := C ^ D
|
|
F := g.rbitAlgorithm(E)
|
|
H := ((F ^ 0xFFFFFFFF) ^ length) & 0xFF
|
|
eorResultList[i] = H
|
|
}
|
|
|
|
result := ""
|
|
for _, param := range eorResultList {
|
|
result += g.hexString(param)
|
|
}
|
|
|
|
return map[string]string{
|
|
"x-ss-req-ticket": strconv.FormatInt(g.unix*1000, 10),
|
|
"x-khronos": strconv.FormatInt(g.unix, 10),
|
|
"x-gorgon": fmt.Sprintf("0404b0d30000%s", result),
|
|
}
|
|
}
|
|
|
|
// GetValue 获取加密值
|
|
func (g *Gorgon) GetValue() map[string]string {
|
|
return g.encrypt(g.getBaseString())
|
|
}
|
|
|