general: add vendor folder

This commit is contained in:
nadoo committed 2018-07-07 11:07:38 +08:00
1 parent 621e8ed018
commit 3c766d0b68
103 files changed
+18061 -19

No files matched your search

+35
View File
@@ -0,0 +1,35 @@
package obfs
import (
"strings"
"github.com/sun8911879/shadowsocksR/ssr"
)
type creator func() IObfs
var (
creatorMap = make(map[string]creator)
)
type IObfs interface {
SetServerInfo(s *ssr.ServerInfoForObfs)
GetServerInfo() (s *ssr.ServerInfoForObfs)
Encode(data []byte) ([]byte, error)
Decode(data []byte) ([]byte, uint64, error)
SetData(data interface{})
GetData() interface{}
}
func register(name string, c creator) {
creatorMap[name] = c
}
// NewObfs create an obfs object by name and return as an IObfs interface
func NewObfs(name string) IObfs {
c, ok := creatorMap[strings.ToLower(name)]
if ok {
return c()
}
return nil
}
+19
View File
@@ -0,0 +1,19 @@
package obfs
import (
"math/rand"
)
func init() {
register("http_post", newHttpPost)
}
// newHttpPost create a http_post object
func newHttpPost() IObfs {
// newHttpSimple create a http_simple object
t := &httpSimplePost{
userAgentIndex: rand.Intn(len(requestUserAgent)),
getOrPost: false,
}
return t
}
+178
View File
@@ -0,0 +1,178 @@
package obfs
import (
"bytes"
"encoding/hex"
"fmt"
"math/rand"
"strings"
"github.com/sun8911879/shadowsocksR/ssr"
)
var (
requestPath = []string{
"", "",
"login.php?redir=", "",
"register.php?code=", "",
"s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&ch=&bar=&wd=", "&rn=",
"post.php?id=", "&goto=view.php",
}
requestUserAgent = []string{
"Mozilla/5.0 (Windows NT 6.3; WOW64; rv:40.0) Gecko/20100101 Firefox/40.0",
"Mozilla/5.0 (Windows NT 6.3; WOW64; rv:40.0) Gecko/20100101 Firefox/44.0",
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36",
"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Ubuntu/11.10 Chromium/27.0.1453.93 Chrome/27.0.1453.93 Safari/537.36",
"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:35.0) Gecko/20100101 Firefox/35.0",
"Mozilla/5.0 (compatible; WOW64; MSIE 10.0; Windows NT 6.2)",
"Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27",
"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.3; Trident/7.0; .NET4.0E; .NET4.0C)",
"Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko",
"Mozilla/5.0 (Linux; Android 4.4; Nexus 5 Build/BuildID) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/30.0.0.0 Mobile Safari/537.36",
"Mozilla/5.0 (iPad; CPU OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3",
"Mozilla/5.0 (iPhone; CPU iPhone OS 5_0 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9A334 Safari/7534.48.3",
}
)
// HttpSimple http_simple obfs encapsulate
type httpSimplePost struct {
ssr.ServerInfoForObfs
rawTransSent bool
rawTransReceived bool
userAgentIndex int
getOrPost bool // true for get, false for post
}
func init() {
register("http_simple", newHttpSimple)
}
// newHttpSimple create a http_simple object
func newHttpSimple() IObfs {
t := &httpSimplePost{
rawTransSent: false,
rawTransReceived: false,
userAgentIndex: rand.Intn(len(requestUserAgent)),
getOrPost: true,
}
return t
}
func (t *httpSimplePost) SetServerInfo(s *ssr.ServerInfoForObfs) {
t.ServerInfoForObfs = *s
}
func (t *httpSimplePost) GetServerInfo() (s *ssr.ServerInfoForObfs) {
return &t.ServerInfoForObfs
}
func (t *httpSimplePost) SetData(data interface{}) {
}
func (t *httpSimplePost) GetData() interface{} {
return nil
}
func (t *httpSimplePost) boundary() (ret string) {
set := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
for i := 0; i < 32; i++ {
ret = fmt.Sprintf("%s%c", ret, set[rand.Intn(len(set))])
}
return
}
func (t *httpSimplePost) data2URLEncode(data []byte) (ret string) {
for i := 0; i < len(data); i++ {
ret = fmt.Sprintf("%s%%%s", ret, hex.EncodeToString([]byte{data[i]}))
}
return
}
func (t *httpSimplePost) Encode(data []byte) (encodedData []byte, err error) {
if t.rawTransSent {
return data, nil
}
dataLength := len(data)
var headData []byte
if headSize := t.IVLen + t.HeadLen; dataLength-headSize > 64 {
headData = make([]byte, headSize+rand.Intn(64))
} else {
headData = make([]byte, dataLength)
}
copy(headData, data[0:len(headData)])
requestPathIndex := rand.Intn(len(requestPath)/2) * 2
host := t.Host
var customHead string
if len(t.Param) > 0 {
customHeads := strings.Split(t.Param, "#")
if len(customHeads) > 2 {
customHeads = customHeads[0:2]
}
param := t.Param
if len(customHeads) > 1 {
customHead = customHeads[1]
param = customHeads[0]
}
hosts := strings.Split(param, ",")
if len(hosts) > 0 {
host = strings.TrimSpace(hosts[rand.Intn(len(hosts))])
}
}
method := "GET /"
if !t.getOrPost {
method = "POST /"
}
httpBuf := fmt.Sprintf("%s%s%s%s HTTP/1.1\r\nHost: %s:%d\r\n",
method,
requestPath[requestPathIndex],
t.data2URLEncode(headData),
requestPath[requestPathIndex+1],
host,
t.Port)
if len(customHead) > 0 {
httpBuf = httpBuf + strings.Replace(customHead, "\\n", "\r\n", -1) + "\r\n\r\n"
} else {
var contentType string
if !t.getOrPost {
contentType = "Content-Type: multipart/form-data; boundary=" + t.boundary() + "\r\n"
}
httpBuf = httpBuf +
"User-Agent: " + requestUserAgent[t.userAgentIndex] + "\r\n" +
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n" +
"Accept-Language: en-US,en;q=0.8\r\n" +
"Accept-Encoding: gzip, deflate\r\n" +
contentType +
"DNT: 1\r\n" +
"Connection: keep-alive\r\n" +
"\r\n"
}
if len(headData) < dataLength {
encodedData = make([]byte, len(httpBuf)+(dataLength-len(headData)))
copy(encodedData, []byte(httpBuf))
copy(encodedData[len(httpBuf):], data[len(headData):])
} else {
encodedData = []byte(httpBuf)
}
t.rawTransSent = true
return
}
func (t *httpSimplePost) Decode(data []byte) ([]byte, uint64, error) {
if t.rawTransReceived {
return data, 0, nil
}
pos := bytes.Index(data, []byte("\r\n\r\n"))
if pos > 0 {
decodedData := make([]byte, len(data)-pos-4)
copy(decodedData, data[pos+4:])
t.rawTransReceived = true
return decodedData, 0, nil
}
return nil, 0, nil
}
+42
View File
@@ -0,0 +1,42 @@
package obfs
import (
"github.com/sun8911879/shadowsocksR/ssr"
)
func init() {
register("plain", newPlainObfs)
}
type plain struct {
ssr.ServerInfoForObfs
}
func newPlainObfs() IObfs {
p := &plain{}
return p
}
func (p *plain) SetServerInfo(s *ssr.ServerInfoForObfs) {
p.ServerInfoForObfs = *s
}
func (p *plain) GetServerInfo() (s *ssr.ServerInfoForObfs) {
return &p.ServerInfoForObfs
}
func (p *plain) Encode(data []byte) (encodedData []byte, err error) {
return data, nil
}
func (p *plain) Decode(data []byte) ([]byte, uint64, error) {
return data, 0, nil
}
func (p *plain) SetData(data interface{}) {
}
func (p *plain) GetData() interface{} {
return nil
}
+79
View File
@@ -0,0 +1,79 @@
package obfs
import (
"math/rand"
"github.com/sun8911879/shadowsocksR/ssr"
)
type randomHead struct {
ssr.ServerInfoForObfs
rawTransSent bool
rawTransReceived bool
hasSentHeader bool
dataBuffer []byte
}
func init() {
register("random_head", newRandomHead)
}
func newRandomHead() IObfs {
p := &randomHead{}
return p
}
func (r *randomHead) SetServerInfo(s *ssr.ServerInfoForObfs) {
r.ServerInfoForObfs = *s
}
func (r *randomHead) GetServerInfo() (s *ssr.ServerInfoForObfs) {
return &r.ServerInfoForObfs
}
func (r *randomHead) SetData(data interface{}) {
}
func (r *randomHead) GetData() interface{} {
return nil
}
func (r *randomHead) Encode(data []byte) (encodedData []byte, err error) {
if r.rawTransSent {
return data, nil
}
dataLength := len(data)
if r.hasSentHeader {
if dataLength > 0 {
d := make([]byte, len(r.dataBuffer)+dataLength)
copy(d, r.dataBuffer)
copy(d[len(r.dataBuffer):], data)
r.dataBuffer = d
} else {
encodedData = r.dataBuffer
r.dataBuffer = nil
r.rawTransSent = true
}
} else {
size := rand.Intn(96) + 8
encodedData = make([]byte, size)
rand.Read(encodedData)
ssr.SetCRC32(encodedData, size)
d := make([]byte, dataLength)
copy(d, data)
r.dataBuffer = d
}
r.hasSentHeader = true
return
}
func (r *randomHead) Decode(data []byte) ([]byte, uint64, error) {
if r.rawTransReceived {
return data, 0, nil
}
r.rawTransReceived = true
return data, 0, nil
}
+279
View File
@@ -0,0 +1,279 @@
package obfs
import (
"crypto/hmac"
"encoding/binary"
"fmt"
"math/rand"
"strings"
"time"
"github.com/sun8911879/shadowsocksR/ssr"
"github.com/sun8911879/shadowsocksR/tools"
)
func init() {
register("tls1.2_ticket_auth", newTLS12TicketAuth)
}
type tlsAuthData struct {
localClientID [32]byte
}
// tls12TicketAuth tls1.2_ticket_auth obfs encapsulate
type tls12TicketAuth struct {
ssr.ServerInfoForObfs
data *tlsAuthData
sendID int
handshakeStatus int
sendBuffer []byte
}
// newTLS12TicketAuth create a tlv1.2_ticket_auth object
func newTLS12TicketAuth() IObfs {
return &tls12TicketAuth{}
}
func (t *tls12TicketAuth) SetServerInfo(s *ssr.ServerInfoForObfs) {
t.ServerInfoForObfs = *s
}
func (t *tls12TicketAuth) GetServerInfo() (s *ssr.ServerInfoForObfs) {
return &t.ServerInfoForObfs
}
func (t *tls12TicketAuth) SetData(data interface{}) {
if auth, ok := data.(*tlsAuthData); ok {
t.data = auth
}
}
func (t *tls12TicketAuth) GetData() interface{} {
if t.data == nil {
t.data = &tlsAuthData{}
b := make([]byte, 32)
rand.Read(b)
copy(t.data.localClientID[:], b)
}
return t.data
}
func (t *tls12TicketAuth) getHost() string {
host := t.Host
if len(t.Param) > 0 {
hosts := strings.Split(t.Param, ",")
if len(hosts) > 0 {
host = hosts[rand.Intn(len(hosts))]
host = strings.TrimSpace(host)
}
}
if len(host) > 0 && host[len(host)-1] >= byte('0') && host[len(host)-1] <= byte('9') && len(t.Param) == 0 {
host = ""
}
return host
}
func (t *tls12TicketAuth) Encode(data []byte) (encodedData []byte, err error) {
if t.handshakeStatus == -1 {
return data, nil
}
dataLength := len(data)
if t.handshakeStatus == 8 {
encodedData = make([]byte, dataLength+4096)
start := 0
outLength := 0
for t.sendID <= 4 && dataLength-start > 256 {
length := rand.Intn(512) + 64
if length > dataLength-start {
length = dataLength - start
}
copy(encodedData[outLength:], []byte{0x17, 0x3, 0x3})
binary.BigEndian.PutUint16(encodedData[outLength+3:], uint16(length&0xFFFF))
copy(encodedData[outLength+5:], data[start:start+length])
start += length
outLength += length + 5
t.sendID++
}
for dataLength-start > 2048 {
length := rand.Intn(3990) + 100
if length > dataLength-start {
length = dataLength - start
}
copy(encodedData[outLength:], []byte{0x17, 0x3, 0x3})
binary.BigEndian.PutUint16(encodedData[outLength+3:], uint16(length&0xFFFF))
copy(encodedData[outLength+5:], data[start:start+length])
start += length
outLength += length + 5
t.sendID++
}
if dataLength-start > 0 {
length := dataLength - start
copy(encodedData[outLength:], []byte{0x17, 0x3, 0x3})
binary.BigEndian.PutUint16(encodedData[outLength+3:], uint16(length&0xFFFF))
copy(encodedData[outLength+5:], data[start:start+length])
// not necessary to update variable *start* any more
outLength += length + 5
t.sendID++
}
encodedData = encodedData[:outLength]
return
}
if t.handshakeStatus == 1 {
//outLength := 0
if dataLength > 0 {
b := make([]byte, len(t.sendBuffer)+dataLength+5)
copy(b, t.sendBuffer)
copy(b[len(t.sendBuffer):], []byte{0x17, 0x3, 0x3})
binary.BigEndian.PutUint16(b[len(t.sendBuffer)+3:], uint16(dataLength&0xFFFF))
copy(b[len(t.sendBuffer)+5:], data)
t.sendBuffer = b
return []byte{}, nil
}
hmacData := make([]byte, 43)
rnd := make([]byte, 22)
rand.Read(rnd)
handshakeFinish := []byte("\x14\x03\x03\x00\x01\x01\x16\x03\x03\x00\x20")
copy(hmacData, handshakeFinish)
copy(hmacData[len(handshakeFinish):], rnd)
h := t.hmacSHA1(hmacData[:33])
copy(hmacData[33:], h)
encodedData = make([]byte, len(hmacData)+len(t.sendBuffer))
copy(encodedData, hmacData)
copy(encodedData[len(hmacData):], t.sendBuffer)
t.sendBuffer = nil
t.handshakeStatus = 8
return
}
rnd := t.packAuthData()
tlsData0 := []byte("\x00\x1c\xc0\x2b\xc0\x2f\xcc\xa9\xcc\xa8\xcc\x14\xcc\x13\xc0\x0a\xc0\x14\xc0\x09\xc0\x13\x00\x9c\x00\x35\x00\x2f\x00\x0a\x01\x00")
tlsData1 := []byte("\xff\x01\x00\x01\x00")
tlsData2 := []byte("\x00\x17\x00\x00\x00\x23\x00\xd0")
tlsData3 := []byte("\x00\x0d\x00\x16\x00\x14\x06\x01\x06\x03\x05\x01\x05\x03\x04\x01\x04\x03\x03\x01\x03\x03\x02\x01\x02\x03\x00\x05\x00\x05\x01\x00\x00\x00\x00\x00\x12\x00\x00\x75\x50\x00\x00\x00\x0b\x00\x02\x01\x00\x00\x0a\x00\x06\x00\x04\x00\x17\x00\x18" +
"\x00\x15\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
var sslBuf []byte
sslBuf = append(sslBuf, rnd...)
sslBuf = append(sslBuf, byte(32))
sslBuf = append(sslBuf, t.data.localClientID[:]...)
sslBuf = append(sslBuf, tlsData0...)
var extBuf []byte
extBuf = append(extBuf, tlsData1...)
host := t.getHost()
extBuf = append(extBuf, t.sni(host)...)
extBuf = append(extBuf, tlsData2...)
ticket := make([]byte, 208)
rand.Read(ticket)
extBuf = append(extBuf, ticket...)
extBuf = append(extBuf, tlsData3...)
extBuf = append([]byte{byte(len(extBuf) / 256), byte(len(extBuf) % 256)}, extBuf...)
sslBuf = append(sslBuf, extBuf...)
// client version
sslBuf = append([]byte{3, 3}, sslBuf...)
// length
sslBuf = append([]byte{1, 0, byte(len(sslBuf) / 256), byte(len(sslBuf) % 256)}, sslBuf...)
// length
sslBuf = append([]byte{byte(len(sslBuf) / 256), byte(len(sslBuf) % 256)}, sslBuf...)
// version
sslBuf = append([]byte{0x16, 3, 1}, sslBuf...)
encodedData = sslBuf
d := make([]byte, dataLength+5)
copy(d[0:], []byte{0x17, 0x3, 0x3})
binary.BigEndian.PutUint16(d[3:], uint16(dataLength&0xFFFF))
copy(d[5:], data)
b := make([]byte, len(t.sendBuffer)+len(d))
copy(b, t.sendBuffer)
copy(b[len(t.sendBuffer):], d)
t.sendBuffer = b
t.handshakeStatus = 1
return
}
func (t *tls12TicketAuth) Decode(data []byte) ([]byte, uint64, error) {
if t.handshakeStatus == -1 {
return data, 0, nil
}
dataLength := len(data)
if t.handshakeStatus == 8 {
if dataLength < 5 {
return nil, 5, fmt.Errorf("data need minimum length: 5 ,data only length: %d", dataLength)
}
if data[0] != 0x17 {
return nil, 0, ssr.ErrTLS12TicketAuthIncorrectMagicNumber
}
size := int(binary.BigEndian.Uint16(data[3:5]))
if size+5 > dataLength {
return nil, uint64(size + 5), fmt.Errorf("unexpected data length: %d ,data only length: %d", size+5, dataLength)
}
if dataLength == size+5 {
return data[5:], 0, nil
}
return data[5 : 5+size], uint64(size + 5), nil
}
if dataLength < 11+32+1+32 {
return nil, 0, ssr.ErrTLS12TicketAuthTooShortData
}
hash := t.hmacSHA1(data[11 : 11+22])
if !hmac.Equal(data[33:33+ssr.ObfsHMACSHA1Len], hash) {
return nil, 0, ssr.ErrTLS12TicketAuthHMACError
}
return nil, 1, nil
}
func (t *tls12TicketAuth) packAuthData() (outData []byte) {
outSize := 32
outData = make([]byte, outSize)
now := time.Now().Unix()
binary.BigEndian.PutUint32(outData[0:4], uint32(now))
rand.Read(outData[4 : 4+18])
hash := t.hmacSHA1(outData[:outSize-ssr.ObfsHMACSHA1Len])
copy(outData[outSize-ssr.ObfsHMACSHA1Len:], hash)
return
}
func (t *tls12TicketAuth) hmacSHA1(data []byte) []byte {
key := make([]byte, t.KeyLen+32)
copy(key, t.Key)
copy(key[t.KeyLen:], t.data.localClientID[:])
sha1Data := tools.HmacSHA1(key, data)
return sha1Data[:ssr.ObfsHMACSHA1Len]
}
func (t *tls12TicketAuth) sni(u string) []byte {
bURL := []byte(u)
length := len(bURL)
ret := make([]byte, length+9)
copy(ret[9:9+length], bURL)
binary.BigEndian.PutUint16(ret[7:], uint16(length&0xFFFF))
length += 3
binary.BigEndian.PutUint16(ret[4:], uint16(length&0xFFFF))
length += 2
binary.BigEndian.PutUint16(ret[2:], uint16(length&0xFFFF))
return ret
}