175 lines
3.5 KiB
Go
175 lines
3.5 KiB
Go
package algos
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"math/rand"
|
|
)
|
|
|
|
// Algo8404 8404加密器
|
|
type Algo8404 struct {
|
|
unix int64
|
|
params string
|
|
xSSStub string
|
|
}
|
|
|
|
// NewAlgo8404 创建新的Algo8404实例
|
|
func NewAlgo8404(params string, unix int64, xSSStub string) *Algo8404 {
|
|
if xSSStub == "" {
|
|
xSSStub = "00000000000000000000000000000000"
|
|
}
|
|
return &Algo8404{
|
|
unix: unix,
|
|
params: params,
|
|
xSSStub: xSSStub,
|
|
}
|
|
}
|
|
|
|
// getXGorgon 生成X-Gorgon签名
|
|
func (a *Algo8404) getXGorgon() string {
|
|
timeHex := fmt.Sprintf("%x", a.unix)
|
|
timeBin, _ := hex.DecodeString(timeHex)
|
|
|
|
m := md5.Sum([]byte(a.params))
|
|
mBytes := m[:4]
|
|
|
|
var aaa []byte
|
|
if a.xSSStub != "" {
|
|
stubBytes, _ := hex.DecodeString(a.xSSStub)
|
|
if len(stubBytes) >= 4 {
|
|
aaa = stubBytes[:4]
|
|
} else {
|
|
aaa = make([]byte, 4)
|
|
}
|
|
} else {
|
|
aaa = make([]byte, 4)
|
|
}
|
|
|
|
// 生成随机数
|
|
a1 := rand.Intn(256)
|
|
a2 := rand.Intn(256)
|
|
|
|
// 构建数据
|
|
data := make([]byte, 0)
|
|
data = append(data, mBytes...)
|
|
data = append(data, aaa...)
|
|
data = append(data, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x04}...)
|
|
data = append(data, timeBin...)
|
|
|
|
// 初始化表
|
|
table := make([]int, 256)
|
|
for i := 0; i < 256; i++ {
|
|
table[i] = i
|
|
}
|
|
|
|
key := []int{0x4A, 0x00, 0x16, a2, 0x47, 0x6C, 0x00, a1}
|
|
|
|
// 第一轮处理
|
|
w8 := 0
|
|
for i := 0; i < 256; i++ {
|
|
keyI := i & 7
|
|
w10 := key[keyI]
|
|
w9 := w8 + table[i]
|
|
w9 = (w9 + w10) & 0xFFFFFFFF
|
|
w10 = w9
|
|
w10 &= 0xFFFFFF00
|
|
w20 := (w9 - w10) & 0xFFFFFFFF
|
|
table[i] = table[w20]
|
|
w8 = w20
|
|
}
|
|
|
|
// 第二轮处理
|
|
dataArr := make([]int, len(data))
|
|
for i, b := range data {
|
|
dataArr[i] = int(b)
|
|
}
|
|
|
|
w26 := 0
|
|
for i := 0; i < len(dataArr); i++ {
|
|
w25 := i
|
|
w8_ := w25 ^ 1
|
|
w9_ := ((w25 & 1) << 1) & 2
|
|
w8_ = (w9_ + w8_) & 0xFFFFFFFF
|
|
x10 := w8_ & 0xFF
|
|
|
|
w9b := table[x10]
|
|
w11 := (w26 ^ w9b) & 0xFFFFFFFF
|
|
w9c := ((w26 | w9b) << 1) & 0xFFFFFFFF
|
|
w9c = (w9c - w11) & 0xFFFFFFFF
|
|
w26 = w9c
|
|
x11 := w26 & 0xFF
|
|
|
|
w12 := table[x11]
|
|
table[x10] = w12
|
|
table[x11] = w12
|
|
|
|
w10_ := w12
|
|
w11_ := dataArr[i]
|
|
w13_ := w10_ | w12
|
|
w10b := w10_ & w12
|
|
wX10 := (w13_ + w10b) & 0xFF
|
|
ks := table[wX10]
|
|
|
|
dataArr[i] = ks ^ w11_
|
|
}
|
|
|
|
// 第三轮处理
|
|
w2 := 0xFFFFFFAA
|
|
w3 := 0x55
|
|
w4 := 0x33
|
|
w8_2 := (^len(dataArr)) & 0xFFFFFFFF
|
|
|
|
for i := 0; i < len(dataArr); i++ {
|
|
val := dataArr[i]
|
|
w16 := ((val >> 4) & 0x0F) | ((val & 0x0F) << 4)
|
|
dataArr[i] = w16 & 0xFF
|
|
|
|
if i == len(dataArr)-1 {
|
|
dataArr[i] = dataArr[0] ^ w16
|
|
} else {
|
|
w7 := dataArr[i]
|
|
w16n := dataArr[i+1]
|
|
w20 := w7 | w16n
|
|
wI2 := w7 & w16n
|
|
dataArr[i] = (w20 - wI2) & 0xFF
|
|
}
|
|
|
|
w13_ := dataArr[i]
|
|
t1 := w2 & (w13_ << 1)
|
|
t2 := w3 & (w13_ >> 1)
|
|
w13_ = t1 | t2
|
|
t3 := w13_ << 2
|
|
t4 := w4 & (w13_ >> 2)
|
|
mix := (t3 & 0xFFFFFFCF) | t4
|
|
high := (mix >> 4) & 0x0F
|
|
low := mix & 0x0FFFFFFF
|
|
mix = ((low << 4) | high) & 0xFFFFFFFF
|
|
w13_ = mix ^ w8_2
|
|
|
|
dataArr[i] = w13_ & 0xFF
|
|
}
|
|
|
|
// 构建输出
|
|
output := make([]byte, 0)
|
|
output = append(output, 0x84, 0x04)
|
|
output = append(output, byte(a1), byte(a2))
|
|
output = append(output, 0x00, 0x00)
|
|
|
|
for _, val := range dataArr {
|
|
output = append(output, byte(val))
|
|
}
|
|
|
|
return hex.EncodeToString(output)
|
|
}
|
|
|
|
// GetValue 获取加密值
|
|
func (a *Algo8404) GetValue() map[string]string {
|
|
return map[string]string{
|
|
"X-Gorgon": a.getXGorgon(),
|
|
"X-Khronos": fmt.Sprintf("%d", a.unix),
|
|
"X-SS-REQ-Ticket": fmt.Sprintf("%d", a.unix*1000),
|
|
}
|
|
}
|
|
|