132 lines
3.2 KiB
Go
132 lines
3.2 KiB
Go
package ss
|
|
|
|
import (
|
|
"crypto/hmac"
|
|
"crypto/sha1"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"strconv"
|
|
|
|
"bitbucket.org/snail/proxy/utils"
|
|
)
|
|
|
|
const leakyBufSize = 4108 // data.len(2) + hmacsha1(10) + data(4096)
|
|
const maxNBuf = 2048
|
|
|
|
var leakyBuf = utils.NewLeakyBuf(maxNBuf, leakyBufSize)
|
|
|
|
func IsFileExists(path string) (bool, error) {
|
|
stat, err := os.Stat(path)
|
|
if err == nil {
|
|
if stat.Mode()&os.ModeType == 0 {
|
|
return true, nil
|
|
}
|
|
return false, errors.New(path + " exists but is not regular file")
|
|
}
|
|
if os.IsNotExist(err) {
|
|
return false, nil
|
|
}
|
|
return false, err
|
|
}
|
|
|
|
func HmacSha1(key []byte, data []byte) []byte {
|
|
hmacSha1 := hmac.New(sha1.New, key)
|
|
hmacSha1.Write(data)
|
|
return hmacSha1.Sum(nil)[:10]
|
|
}
|
|
|
|
func otaConnectAuth(iv, key, data []byte) []byte {
|
|
return append(data, HmacSha1(append(iv, key...), data)...)
|
|
}
|
|
|
|
func otaReqChunkAuth(iv []byte, 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, HmacSha1(append(iv, chunkIdBytes...), data)...)
|
|
return append(header, data...)
|
|
}
|
|
|
|
const (
|
|
idType = 0 // address type index
|
|
idIP0 = 1 // ip addres start index
|
|
idDmLen = 1 // domain address length index
|
|
idDm0 = 2 // domain address start index
|
|
|
|
typeIPv4 = 1 // type is ipv4 address
|
|
typeDm = 3 // type is domain address
|
|
typeIPv6 = 4 // type is ipv6 address
|
|
|
|
lenIPv4 = net.IPv4len + 2 // ipv4 + 2port
|
|
lenIPv6 = net.IPv6len + 2 // ipv6 + 2port
|
|
lenDmBase = 2 // 1addrLen + 2port, plus addrLen
|
|
lenHmacSha1 = 10
|
|
)
|
|
|
|
func GetRequest(conn *Conn) (host string, err error) {
|
|
|
|
// buf size should at least have the same size with the largest possible
|
|
// request size (when addrType is 3, domain name has at most 256 bytes)
|
|
// 1(addrType) + 1(lenByte) + 255(max length address) + 2(port) + 10(hmac-sha1)
|
|
buf := make([]byte, 269)
|
|
// read till we get possible domain length field
|
|
if _, err = io.ReadFull(conn, buf[:idType+1]); err != nil {
|
|
return
|
|
}
|
|
|
|
var reqStart, reqEnd int
|
|
addrType := buf[idType]
|
|
switch addrType & AddrMask {
|
|
case typeIPv4:
|
|
reqStart, reqEnd = idIP0, idIP0+lenIPv4
|
|
case typeIPv6:
|
|
reqStart, reqEnd = idIP0, idIP0+lenIPv6
|
|
case typeDm:
|
|
if _, err = io.ReadFull(conn, buf[idType+1:idDmLen+1]); err != nil {
|
|
return
|
|
}
|
|
reqStart, reqEnd = idDm0, idDm0+int(buf[idDmLen])+lenDmBase
|
|
default:
|
|
err = fmt.Errorf("addr type %d not supported", addrType&AddrMask)
|
|
return
|
|
}
|
|
|
|
if _, err = io.ReadFull(conn, buf[reqStart:reqEnd]); err != nil {
|
|
return
|
|
}
|
|
|
|
// Return string for typeIP is not most efficient, but browsers (Chrome,
|
|
// Safari, Firefox) all seems using typeDm exclusively. So this is not a
|
|
// big problem.
|
|
switch addrType & AddrMask {
|
|
case typeIPv4:
|
|
host = net.IP(buf[idIP0 : idIP0+net.IPv4len]).String()
|
|
case typeIPv6:
|
|
host = net.IP(buf[idIP0 : idIP0+net.IPv6len]).String()
|
|
case typeDm:
|
|
host = string(buf[idDm0 : idDm0+int(buf[idDmLen])])
|
|
}
|
|
// parse port
|
|
port := binary.BigEndian.Uint16(buf[reqEnd-2 : reqEnd])
|
|
host = net.JoinHostPort(host, strconv.Itoa(int(port)))
|
|
|
|
return
|
|
}
|
|
|
|
type ClosedFlag struct {
|
|
flag bool
|
|
}
|
|
|
|
func (flag *ClosedFlag) SetClosed() {
|
|
flag.flag = true
|
|
}
|
|
|
|
func (flag *ClosedFlag) IsClosed() bool {
|
|
return flag.flag
|
|
}
|