mirror of
https://github.com/nadoo/glider.git
synced 2026-11-19 07:09:42 +08:00
general: add vendor folder
This commit is contained in:
1 parent
621e8ed018
commit
3c766d0b68
103 files changed
+18061
-19
No files matched your search
+282
@@ -0,0 +1,282 @@
|
||||
package protocol
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"encoding/base64"
|
||||
"encoding/binary"
|
||||
"math/rand"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/sun8911879/shadowsocksR/ssr"
|
||||
"github.com/sun8911879/shadowsocksR/tools"
|
||||
)
|
||||
|
||||
type hmacMethod func(key []byte, data []byte) []byte
|
||||
type hashDigestMethod func(data []byte) []byte
|
||||
|
||||
func init() {
|
||||
register("auth_aes128_md5", NewAuthAES128MD5)
|
||||
}
|
||||
|
||||
func NewAuthAES128MD5() IProtocol {
|
||||
a := &authAES128{
|
||||
salt: "auth_aes128_md5",
|
||||
hmac: tools.HmacMD5,
|
||||
hashDigest: tools.MD5Sum,
|
||||
packID: 1,
|
||||
recvInfo: recvInfo{
|
||||
recvID: 1,
|
||||
buffer: bytes.NewBuffer(nil),
|
||||
},
|
||||
data: &authData{
|
||||
connectionID: 0xFF000001,
|
||||
},
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
type recvInfo struct {
|
||||
recvID uint32
|
||||
buffer *bytes.Buffer
|
||||
}
|
||||
|
||||
type authAES128 struct {
|
||||
ssr.ServerInfoForObfs
|
||||
recvInfo
|
||||
data *authData
|
||||
hasSentHeader bool
|
||||
packID uint32
|
||||
userKey []byte
|
||||
salt string
|
||||
hmac hmacMethod
|
||||
hashDigest hashDigestMethod
|
||||
}
|
||||
|
||||
func (a *authAES128) SetServerInfo(s *ssr.ServerInfoForObfs) {
|
||||
a.ServerInfoForObfs = *s
|
||||
}
|
||||
|
||||
func (a *authAES128) GetServerInfo() (s *ssr.ServerInfoForObfs) {
|
||||
return &a.ServerInfoForObfs
|
||||
}
|
||||
|
||||
func (a *authAES128) SetData(data interface{}) {
|
||||
if auth, ok := data.(*authData); ok {
|
||||
a.data = auth
|
||||
}
|
||||
}
|
||||
|
||||
func (a *authAES128) GetData() interface{} {
|
||||
if a.data == nil {
|
||||
a.data = &authData{}
|
||||
}
|
||||
return a.data
|
||||
}
|
||||
|
||||
func (a *authAES128) packData(data []byte) (outData []byte) {
|
||||
dataLength := len(data)
|
||||
randLength := 1
|
||||
if dataLength <= 1200 {
|
||||
if a.packID > 4 {
|
||||
randLength += rand.Intn(32)
|
||||
} else {
|
||||
if dataLength > 900 {
|
||||
randLength += rand.Intn(128)
|
||||
} else {
|
||||
randLength += rand.Intn(512)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
outLength := randLength + dataLength + 8
|
||||
outData = make([]byte, outLength)
|
||||
// 0~1, out length
|
||||
binary.LittleEndian.PutUint16(outData[0:], uint16(outLength&0xFFFF))
|
||||
// 2~3, hmac
|
||||
key := make([]byte, len(a.userKey)+4)
|
||||
copy(key, a.userKey)
|
||||
binary.LittleEndian.PutUint32(key[len(key)-4:], a.packID)
|
||||
h := a.hmac(key, outData[0:2])
|
||||
copy(outData[2:4], h[:2])
|
||||
// 4~rand length+4, rand number
|
||||
rand.Read(outData[4 : 4+randLength])
|
||||
// 4, rand length
|
||||
if randLength < 128 {
|
||||
outData[4] = byte(randLength & 0xFF)
|
||||
} else {
|
||||
// 4, magic number 0xFF
|
||||
outData[4] = 0xFF
|
||||
// 5~6, rand length
|
||||
binary.LittleEndian.PutUint16(outData[5:], uint16(randLength&0xFFFF))
|
||||
}
|
||||
// rand length+4~out length-4, data
|
||||
if dataLength > 0 {
|
||||
copy(outData[randLength+4:], data)
|
||||
}
|
||||
a.packID++
|
||||
h = a.hmac(key, outData[:outLength-4])
|
||||
copy(outData[outLength-4:], h[:4])
|
||||
return
|
||||
}
|
||||
|
||||
func (a *authAES128) packAuthData(data []byte) (outData []byte) {
|
||||
dataLength := len(data)
|
||||
var randLength int
|
||||
if dataLength > 400 {
|
||||
randLength = rand.Intn(512)
|
||||
} else {
|
||||
randLength = rand.Intn(1024)
|
||||
}
|
||||
|
||||
dataOffset := randLength + 16 + 4 + 4 + 7
|
||||
outLength := dataOffset + dataLength + 4
|
||||
outData = make([]byte, outLength)
|
||||
encrypt := make([]byte, 24)
|
||||
key := make([]byte, a.IVLen+a.KeyLen)
|
||||
copy(key, a.IV)
|
||||
copy(key[a.IVLen:], a.Key)
|
||||
|
||||
rand.Read(outData[dataOffset-randLength:])
|
||||
|
||||
if a.data.connectionID > 0xFF000000 {
|
||||
a.data.clientID = nil
|
||||
}
|
||||
if len(a.data.clientID) == 0 {
|
||||
a.data.clientID = make([]byte, 4)
|
||||
rand.Read(a.data.clientID)
|
||||
b := make([]byte, 4)
|
||||
rand.Read(b)
|
||||
a.data.connectionID = binary.LittleEndian.Uint32(b) & 0xFFFFFF
|
||||
}
|
||||
a.data.connectionID++
|
||||
copy(encrypt[4:], a.data.clientID)
|
||||
binary.LittleEndian.PutUint32(encrypt[8:], a.data.connectionID)
|
||||
|
||||
now := time.Now().Unix()
|
||||
binary.LittleEndian.PutUint32(encrypt[0:4], uint32(now))
|
||||
|
||||
binary.LittleEndian.PutUint16(encrypt[12:], uint16(outLength&0xFFFF))
|
||||
binary.LittleEndian.PutUint16(encrypt[14:], uint16(randLength&0xFFFF))
|
||||
|
||||
params := strings.Split(a.Param, ":")
|
||||
uid := make([]byte, 4)
|
||||
if len(params) >= 2 {
|
||||
if userID, err := strconv.ParseUint(params[0], 10, 32); err != nil {
|
||||
rand.Read(uid)
|
||||
} else {
|
||||
binary.LittleEndian.PutUint32(uid, uint32(userID))
|
||||
a.userKey = a.hashDigest([]byte(params[1]))
|
||||
}
|
||||
} else {
|
||||
rand.Read(uid)
|
||||
}
|
||||
|
||||
if a.userKey == nil {
|
||||
a.userKey = make([]byte, a.KeyLen)
|
||||
copy(a.userKey, a.Key)
|
||||
}
|
||||
|
||||
encryptKey := make([]byte, len(a.userKey))
|
||||
copy(encryptKey, a.userKey)
|
||||
|
||||
aesCipherKey := tools.EVPBytesToKey(base64.StdEncoding.EncodeToString(encryptKey)+a.salt, 16)
|
||||
block, err := aes.NewCipher(aesCipherKey)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
encryptData := make([]byte, 16)
|
||||
iv := make([]byte, aes.BlockSize)
|
||||
cbc := cipher.NewCBCEncrypter(block, iv)
|
||||
cbc.CryptBlocks(encryptData, encrypt[0:16])
|
||||
copy(encrypt[4:4+16], encryptData)
|
||||
copy(encrypt[0:4], uid)
|
||||
|
||||
h := a.hmac(key, encrypt[0:20])
|
||||
copy(encrypt[20:], h[:4])
|
||||
|
||||
rand.Read(outData[0:1])
|
||||
h = a.hmac(key, outData[0:1])
|
||||
copy(outData[1:], h[0:7-1])
|
||||
|
||||
copy(outData[7:], encrypt)
|
||||
copy(outData[dataOffset:], data)
|
||||
|
||||
h = a.hmac(a.userKey, outData[0:outLength-4])
|
||||
copy(outData[outLength-4:], h[:4])
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (a *authAES128) PreEncrypt(plainData []byte) (outData []byte, err error) {
|
||||
dataLength := len(plainData)
|
||||
offset := 0
|
||||
if !a.hasSentHeader {
|
||||
authLength := dataLength
|
||||
if authLength > 1200 {
|
||||
authLength = 1200
|
||||
}
|
||||
packData := a.packAuthData(plainData[:authLength])
|
||||
a.hasSentHeader = true
|
||||
outData = append(outData, packData...)
|
||||
dataLength -= authLength
|
||||
offset += authLength
|
||||
}
|
||||
const blockSize = 4096
|
||||
for dataLength > blockSize {
|
||||
packData := a.packData(plainData[offset : offset+blockSize])
|
||||
outData = append(outData, packData...)
|
||||
dataLength -= blockSize
|
||||
offset += blockSize
|
||||
}
|
||||
if dataLength > 0 {
|
||||
packData := a.packData(plainData[offset:])
|
||||
outData = append(outData, packData...)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (a *authAES128) PostDecrypt(plainData []byte) ([]byte, int, error) {
|
||||
a.buffer.Reset()
|
||||
plainLength := len(plainData)
|
||||
datalength := plainLength
|
||||
readlenth := 0
|
||||
key := make([]byte, len(a.userKey)+4)
|
||||
copy(key, a.userKey)
|
||||
for plainLength > 4 {
|
||||
binary.LittleEndian.PutUint32(key[len(key)-4:], a.recvID)
|
||||
|
||||
h := a.hmac(key, plainData[0:2])
|
||||
if h[0] != plainData[2] || h[1] != plainData[3] {
|
||||
return nil, 0, ssr.ErrAuthAES128HMACError
|
||||
}
|
||||
length := int(binary.LittleEndian.Uint16(plainData[0:2]))
|
||||
if length >= 8192 || length < 8 {
|
||||
return nil, 0, ssr.ErrAuthAES128DataLengthError
|
||||
}
|
||||
if length > plainLength {
|
||||
break
|
||||
}
|
||||
a.recvID++
|
||||
pos := int(plainData[4])
|
||||
if pos < 255 {
|
||||
pos += 4
|
||||
} else {
|
||||
pos = int(binary.LittleEndian.Uint16(plainData[5:7])) + 4
|
||||
}
|
||||
|
||||
a.buffer.Write(plainData[pos : length-4])
|
||||
plainData = plainData[length:]
|
||||
plainLength -= length
|
||||
readlenth += length
|
||||
}
|
||||
if datalength == readlenth {
|
||||
readlenth = -1
|
||||
}
|
||||
return a.buffer.Bytes(), readlenth, nil
|
||||
}
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
package protocol
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
|
||||
"github.com/sun8911879/shadowsocksR/tools"
|
||||
)
|
||||
|
||||
func init() {
|
||||
register("auth_aes128_sha1", NewAuthAES128SHA1)
|
||||
}
|
||||
|
||||
func NewAuthAES128SHA1() IProtocol {
|
||||
a := &authAES128{
|
||||
salt: "auth_aes128_sha1",
|
||||
hmac: tools.HmacSHA1,
|
||||
hashDigest: tools.SHA1Sum,
|
||||
packID: 1,
|
||||
recvInfo: recvInfo{
|
||||
recvID: 1,
|
||||
buffer: bytes.NewBuffer(nil),
|
||||
},
|
||||
data: &authData{
|
||||
connectionID: 0xFF000001,
|
||||
},
|
||||
}
|
||||
return a
|
||||
}
|
||||
+232
@@ -0,0 +1,232 @@
|
||||
package protocol
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"math/rand"
|
||||
"time"
|
||||
|
||||
"github.com/sun8911879/shadowsocksR/ssr"
|
||||
"github.com/sun8911879/shadowsocksR/tools"
|
||||
)
|
||||
|
||||
func init() {
|
||||
register("auth_sha1_v4", NewAuthSHA1v4)
|
||||
}
|
||||
|
||||
type authSHA1v4 struct {
|
||||
ssr.ServerInfoForObfs
|
||||
data *authData
|
||||
hasSentHeader bool
|
||||
recvBuffer []byte
|
||||
recvBufferLength int
|
||||
}
|
||||
|
||||
func NewAuthSHA1v4() IProtocol {
|
||||
a := &authSHA1v4{}
|
||||
return a
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) SetServerInfo(s *ssr.ServerInfoForObfs) {
|
||||
a.ServerInfoForObfs = *s
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) GetServerInfo() (s *ssr.ServerInfoForObfs) {
|
||||
return &a.ServerInfoForObfs
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) SetData(data interface{}) {
|
||||
if auth, ok := data.(*authData); ok {
|
||||
a.data = auth
|
||||
}
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) GetData() interface{} {
|
||||
if a.data == nil {
|
||||
a.data = &authData{}
|
||||
}
|
||||
return a.data
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) packData(data []byte) (outData []byte) {
|
||||
dataLength := len(data)
|
||||
randLength := 1
|
||||
if dataLength <= 1300 {
|
||||
if dataLength > 400 {
|
||||
randLength += rand.Intn(128)
|
||||
} else {
|
||||
randLength += rand.Intn(1024)
|
||||
}
|
||||
}
|
||||
|
||||
outLength := randLength + dataLength + 8
|
||||
outData = make([]byte, outLength)
|
||||
// 0~1, out length
|
||||
binary.BigEndian.PutUint16(outData[0:2], uint16(outLength&0xFFFF))
|
||||
// 2~3, crc of out length
|
||||
crc32 := ssr.CalcCRC32(outData, 2, 0xFFFFFFFF)
|
||||
binary.LittleEndian.PutUint16(outData[2:4], uint16(crc32&0xFFFF))
|
||||
// 4~rand length+4, rand number
|
||||
rand.Read(outData[4 : 4+randLength])
|
||||
// 4, rand length
|
||||
if randLength < 128 {
|
||||
outData[4] = byte(randLength & 0xFF)
|
||||
} else {
|
||||
// 4, magic number 0xFF
|
||||
outData[4] = 0xFF
|
||||
// 5~6, rand length
|
||||
binary.BigEndian.PutUint16(outData[5:], uint16(randLength&0xFFFF))
|
||||
}
|
||||
// rand length+4~out length-4, data
|
||||
if dataLength > 0 {
|
||||
copy(outData[randLength+4:], data)
|
||||
}
|
||||
// out length-4~end, adler32 of full data
|
||||
adler := ssr.CalcAdler32(outData[:outLength-4])
|
||||
binary.LittleEndian.PutUint32(outData[outLength-4:], adler)
|
||||
|
||||
return outData
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) packAuthData(data []byte) (outData []byte) {
|
||||
dataLength := len(data)
|
||||
randLength := 1
|
||||
if dataLength <= 1300 {
|
||||
if dataLength > 400 {
|
||||
randLength += rand.Intn(128)
|
||||
} else {
|
||||
randLength += rand.Intn(1024)
|
||||
}
|
||||
}
|
||||
dataOffset := randLength + 4 + 2
|
||||
outLength := dataOffset + dataLength + 12 + ssr.ObfsHMACSHA1Len
|
||||
outData = make([]byte, outLength)
|
||||
|
||||
a.data.connectionID++
|
||||
if a.data.connectionID > 0xFF000000 {
|
||||
a.data.clientID = nil
|
||||
}
|
||||
if len(a.data.clientID) == 0 {
|
||||
a.data.clientID = make([]byte, 8)
|
||||
rand.Read(a.data.clientID)
|
||||
b := make([]byte, 4)
|
||||
rand.Read(b)
|
||||
a.data.connectionID = binary.LittleEndian.Uint32(b) & 0xFFFFFF
|
||||
}
|
||||
// 0-1, out length
|
||||
binary.BigEndian.PutUint16(outData[0:], uint16(outLength&0xFFFF))
|
||||
|
||||
// 2~6, crc of out length+salt+key
|
||||
salt := []byte("auth_sha1_v4")
|
||||
crcData := make([]byte, len(salt)+a.KeyLen+2)
|
||||
copy(crcData[0:2], outData[0:2])
|
||||
copy(crcData[2:], salt)
|
||||
copy(crcData[2+len(salt):], a.Key)
|
||||
crc32 := ssr.CalcCRC32(crcData, len(crcData), 0xFFFFFFFF)
|
||||
// 2~6, crc of out length+salt+key
|
||||
binary.LittleEndian.PutUint32(outData[2:], crc32)
|
||||
// 6~rand length+6, rand numbers
|
||||
rand.Read(outData[dataOffset-randLength : dataOffset])
|
||||
// 6, rand length
|
||||
if randLength < 128 {
|
||||
outData[6] = byte(randLength & 0xFF)
|
||||
} else {
|
||||
// 6, magic number 0xFF
|
||||
outData[6] = 0xFF
|
||||
// 7-8, rand length
|
||||
binary.BigEndian.PutUint16(outData[7:], uint16(randLength&0xFFFF))
|
||||
}
|
||||
// rand length+6~rand length+10, time stamp
|
||||
now := time.Now().Unix()
|
||||
binary.LittleEndian.PutUint32(outData[dataOffset:dataOffset+4], uint32(now))
|
||||
// rand length+10~rand length+14, client ID
|
||||
copy(outData[dataOffset+4:dataOffset+4+4], a.data.clientID[0:4])
|
||||
// rand length+14~rand length+18, connection ID
|
||||
binary.LittleEndian.PutUint32(outData[dataOffset+8:dataOffset+8+4], a.data.connectionID)
|
||||
// rand length+18~rand length+18+data length, data
|
||||
copy(outData[dataOffset+12:], data)
|
||||
|
||||
key := make([]byte, a.IVLen+a.KeyLen)
|
||||
copy(key, a.IV)
|
||||
copy(key[a.IVLen:], a.Key)
|
||||
|
||||
h := tools.HmacSHA1(key, outData[:outLength-ssr.ObfsHMACSHA1Len])
|
||||
// out length-10~out length/rand length+18+data length~end, hmac
|
||||
copy(outData[outLength-ssr.ObfsHMACSHA1Len:], h[0:ssr.ObfsHMACSHA1Len])
|
||||
|
||||
return outData
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) PreEncrypt(plainData []byte) (outData []byte, err error) {
|
||||
dataLength := len(plainData)
|
||||
offset := 0
|
||||
if !a.hasSentHeader && dataLength > 0 {
|
||||
authLength := dataLength
|
||||
if headSize := ssr.GetHeadSize(plainData, 30); headSize <= dataLength {
|
||||
authLength = headSize
|
||||
}
|
||||
packData := a.packAuthData(plainData[:authLength])
|
||||
a.hasSentHeader = true
|
||||
outData = append(outData, packData...)
|
||||
dataLength -= authLength
|
||||
offset += authLength
|
||||
}
|
||||
const blockSize = 4096
|
||||
for dataLength > blockSize {
|
||||
packData := a.packData(plainData[offset : offset+blockSize])
|
||||
outData = append(outData, packData...)
|
||||
dataLength -= blockSize
|
||||
offset += blockSize
|
||||
}
|
||||
if dataLength > 0 {
|
||||
packData := a.packData(plainData[offset:])
|
||||
outData = append(outData, packData...)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (a *authSHA1v4) PostDecrypt(plainData []byte) ([]byte, int, error) {
|
||||
var outData []byte
|
||||
dataLength := len(plainData)
|
||||
b := make([]byte, len(a.recvBuffer)+dataLength)
|
||||
copy(b, a.recvBuffer)
|
||||
copy(b[len(a.recvBuffer):], plainData)
|
||||
a.recvBuffer = b
|
||||
a.recvBufferLength = len(b)
|
||||
for a.recvBufferLength > 4 {
|
||||
crc32 := ssr.CalcCRC32(a.recvBuffer, 2, 0xFFFFFFFF)
|
||||
if binary.LittleEndian.Uint16(a.recvBuffer[2:4]) != uint16(crc32&0xFFFF) {
|
||||
return nil, 0, ssr.ErrAuthSHA1v4CRC32Error
|
||||
}
|
||||
length := int(binary.BigEndian.Uint16(a.recvBuffer[0:2]))
|
||||
if length >= 8192 || length < 8 {
|
||||
a.recvBufferLength = 0
|
||||
a.recvBuffer = nil
|
||||
return nil, 0, ssr.ErrAuthSHA1v4DataLengthError
|
||||
}
|
||||
if length > a.recvBufferLength {
|
||||
break
|
||||
}
|
||||
|
||||
if ssr.CheckAdler32(a.recvBuffer, length) {
|
||||
pos := int(a.recvBuffer[4])
|
||||
if pos != 0xFF {
|
||||
pos += 4
|
||||
} else {
|
||||
pos = int(binary.BigEndian.Uint16(a.recvBuffer[5:5+2])) + 4
|
||||
}
|
||||
outLength := length - pos - 4
|
||||
b = make([]byte, len(outData)+outLength)
|
||||
copy(b, outData)
|
||||
copy(b[len(outData):], a.recvBuffer[pos:pos+outLength])
|
||||
outData = b
|
||||
a.recvBufferLength -= length
|
||||
a.recvBuffer = a.recvBuffer[length:]
|
||||
} else {
|
||||
a.recvBufferLength = 0
|
||||
a.recvBuffer = nil
|
||||
return nil, 0, ssr.ErrAuthSHA1v4IncorrectChecksum
|
||||
}
|
||||
}
|
||||
return outData, 0, nil
|
||||
}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
package protocol
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/sun8911879/shadowsocksR/ssr"
|
||||
)
|
||||
|
||||
type creator func() IProtocol
|
||||
|
||||
var (
|
||||
creatorMap = make(map[string]creator)
|
||||
)
|
||||
|
||||
type IProtocol interface {
|
||||
SetServerInfo(s *ssr.ServerInfoForObfs)
|
||||
GetServerInfo() *ssr.ServerInfoForObfs
|
||||
PreEncrypt(data []byte) ([]byte, error)
|
||||
PostDecrypt(data []byte) ([]byte, int, error)
|
||||
SetData(data interface{})
|
||||
GetData() interface{}
|
||||
}
|
||||
|
||||
type authData struct {
|
||||
clientID []byte
|
||||
connectionID uint32
|
||||
}
|
||||
|
||||
func register(name string, c creator) {
|
||||
creatorMap[name] = c
|
||||
}
|
||||
|
||||
func NewProtocol(name string) IProtocol {
|
||||
c, ok := creatorMap[strings.ToLower(name)]
|
||||
if ok {
|
||||
return c()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
package protocol
|
||||
|
||||
import (
|
||||
"github.com/sun8911879/shadowsocksR/ssr"
|
||||
)
|
||||
|
||||
func init() {
|
||||
register("origin", NewOrigin)
|
||||
}
|
||||
|
||||
type origin struct {
|
||||
ssr.ServerInfoForObfs
|
||||
}
|
||||
|
||||
func NewOrigin() IProtocol {
|
||||
a := &origin{}
|
||||
return a
|
||||
}
|
||||
|
||||
func (o *origin) SetServerInfo(s *ssr.ServerInfoForObfs) {
|
||||
o.ServerInfoForObfs = *s
|
||||
}
|
||||
|
||||
func (o *origin) GetServerInfo() (s *ssr.ServerInfoForObfs) {
|
||||
return &o.ServerInfoForObfs
|
||||
}
|
||||
|
||||
func (o *origin) PreEncrypt(data []byte) (encryptedData []byte, err error) {
|
||||
return data, nil
|
||||
}
|
||||
|
||||
func (o *origin) PostDecrypt(data []byte) ([]byte, int, error) {
|
||||
return data, 0, nil
|
||||
}
|
||||
|
||||
func (o *origin) SetData(data interface{}) {
|
||||
|
||||
}
|
||||
|
||||
func (o *origin) GetData() interface{} {
|
||||
return nil
|
||||
}
|
||||
+101
@@ -0,0 +1,101 @@
|
||||
package protocol
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
|
||||
"github.com/sun8911879/shadowsocksR/ssr"
|
||||
"github.com/sun8911879/shadowsocksR/tools"
|
||||
)
|
||||
|
||||
func init() {
|
||||
register("verify_sha1", NewVerifySHA1)
|
||||
register("ota", NewVerifySHA1)
|
||||
}
|
||||
|
||||
type verifySHA1 struct {
|
||||
ssr.ServerInfoForObfs
|
||||
hasSentHeader bool
|
||||
chunkId uint32
|
||||
}
|
||||
|
||||
const (
|
||||
oneTimeAuthMask byte = 0x10
|
||||
)
|
||||
|
||||
func NewVerifySHA1() IProtocol {
|
||||
a := &verifySHA1{}
|
||||
return a
|
||||
}
|
||||
|
||||
func (v *verifySHA1) otaConnectAuth(data []byte) []byte {
|
||||
return append(data, tools.HmacSHA1(append(v.IV, v.Key...), data)...)
|
||||
}
|
||||
|
||||
func (v *verifySHA1) otaReqChunkAuth(chunkId uint32, data []byte) []byte {
|
||||
nb := make([]byte, 2)
|
||||
binary.BigEndian.PutUint16(nb, uint16(len(data)))
|
||||
chunkIdBytes := make([]byte, 4)
|
||||
binary.BigEndian.PutUint32(chunkIdBytes, chunkId)
|
||||
header := append(nb, tools.HmacSHA1(append(v.IV, chunkIdBytes...), data)...)
|
||||
return append(header, data...)
|
||||
}
|
||||
|
||||
func (v *verifySHA1) otaVerifyAuth(iv []byte, chunkId uint32, data []byte, expectedHmacSha1 []byte) bool {
|
||||
chunkIdBytes := make([]byte, 4)
|
||||
binary.BigEndian.PutUint32(chunkIdBytes, chunkId)
|
||||
actualHmacSha1 := tools.HmacSHA1(append(iv, chunkIdBytes...), data)
|
||||
return bytes.Equal(expectedHmacSha1, actualHmacSha1)
|
||||
}
|
||||
|
||||
func (v *verifySHA1) getAndIncreaseChunkId() (chunkId uint32) {
|
||||
chunkId = v.chunkId
|
||||
v.chunkId += 1
|
||||
return
|
||||
}
|
||||
|
||||
func (v *verifySHA1) SetServerInfo(s *ssr.ServerInfoForObfs) {
|
||||
v.ServerInfoForObfs = *s
|
||||
}
|
||||
|
||||
func (v *verifySHA1) GetServerInfo() (s *ssr.ServerInfoForObfs) {
|
||||
return &v.ServerInfoForObfs
|
||||
}
|
||||
|
||||
func (v *verifySHA1) SetData(data interface{}) {
|
||||
|
||||
}
|
||||
|
||||
func (v *verifySHA1) GetData() interface{} {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v *verifySHA1) PreEncrypt(data []byte) (encryptedData []byte, err error) {
|
||||
dataLength := len(data)
|
||||
offset := 0
|
||||
if !v.hasSentHeader {
|
||||
data[0] |= oneTimeAuthMask
|
||||
encryptedData = v.otaConnectAuth(data[:v.HeadLen])
|
||||
v.hasSentHeader = true
|
||||
dataLength -= v.HeadLen
|
||||
offset += v.HeadLen
|
||||
}
|
||||
const blockSize = 4096
|
||||
for dataLength > blockSize {
|
||||
chunkId := v.getAndIncreaseChunkId()
|
||||
b := v.otaReqChunkAuth(chunkId, data[offset:offset+blockSize])
|
||||
encryptedData = append(encryptedData, b...)
|
||||
dataLength -= blockSize
|
||||
offset += blockSize
|
||||
}
|
||||
if dataLength > 0 {
|
||||
chunkId := v.getAndIncreaseChunkId()
|
||||
b := v.otaReqChunkAuth(chunkId, data[offset:])
|
||||
encryptedData = append(encryptedData, b...)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (v *verifySHA1) PostDecrypt(data []byte) ([]byte, int, error) {
|
||||
return data, 0, nil
|
||||
}
|
||||
Reference in new issue
Block a user