mirror of https://github.com/ginuerzh/gost
rui.zheng
10 years ago
13 changed files with 627 additions and 151 deletions
@ -1,80 +0,0 @@ |
|||
package main |
|||
|
|||
import ( |
|||
"bufio" |
|||
"flag" |
|||
"fmt" |
|||
"github.com/ginuerzh/gost" |
|||
"github.com/golang/glog" |
|||
"golang.org/x/net/http2" |
|||
"log" |
|||
"net/http" |
|||
"net/http/httputil" |
|||
"net/url" |
|||
) |
|||
|
|||
var ( |
|||
proxyNodes stringlist |
|||
urls []string |
|||
) |
|||
|
|||
func init() { |
|||
flag.Var(&proxyNodes, "F", "forward address, can make a forward chain") |
|||
flag.Parse() |
|||
if flag.NArg() == 0 { |
|||
log.Fatal("please specific at least one request URL") |
|||
} |
|||
urls = flag.Args() |
|||
if glog.V(5) { |
|||
http2.VerboseLogs = true |
|||
} |
|||
} |
|||
|
|||
type stringlist []string |
|||
|
|||
func (list *stringlist) String() string { |
|||
return fmt.Sprintf("%s", *list) |
|||
} |
|||
func (list *stringlist) Set(value string) error { |
|||
*list = append(*list, value) |
|||
return nil |
|||
} |
|||
|
|||
func main() { |
|||
chain := gost.NewProxyChain() |
|||
if err := chain.AddProxyNodeString(proxyNodes...); err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
chain.TryEnableHttp2() |
|||
|
|||
for _, u := range urls { |
|||
url, err := url.Parse(u) |
|||
if err != nil { |
|||
log.Println("Invalid url:", u) |
|||
continue |
|||
} |
|||
|
|||
log.Println("GET", u) |
|||
conn, err := chain.Dial(url.Host) |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
req, err := http.NewRequest("GET", u, nil) |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
|
|||
if err := req.Write(conn); err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
resp, err := http.ReadResponse(bufio.NewReader(conn), req) |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
defer resp.Body.Close() |
|||
|
|||
header, _ := httputil.DumpResponse(resp, false) |
|||
log.Println(string(header)) |
|||
} |
|||
|
|||
} |
|||
@ -1,53 +0,0 @@ |
|||
package main |
|||
|
|||
import ( |
|||
"crypto/tls" |
|||
"flag" |
|||
"fmt" |
|||
"github.com/ginuerzh/gost" |
|||
"log" |
|||
"sync" |
|||
) |
|||
|
|||
var ( |
|||
proxyNodes stringlist |
|||
) |
|||
|
|||
func init() { |
|||
flag.Var(&proxyNodes, "L", "proxy server node") |
|||
flag.Parse() |
|||
} |
|||
|
|||
type stringlist []string |
|||
|
|||
func (list *stringlist) String() string { |
|||
return fmt.Sprintf("%s", *list) |
|||
} |
|||
func (list *stringlist) Set(value string) error { |
|||
*list = append(*list, value) |
|||
return nil |
|||
} |
|||
|
|||
func main() { |
|||
chain := gost.NewProxyChain() |
|||
var wg sync.WaitGroup |
|||
for _, ns := range proxyNodes { |
|||
serverNode, err := gost.ParseProxyNode(ns) |
|||
if err != nil { |
|||
log.Println(err) |
|||
continue |
|||
} |
|||
wg.Add(1) |
|||
go func(node gost.ProxyNode) { |
|||
defer wg.Done() |
|||
cert, err := gost.LoadCertificate(node.Get("cert"), node.Get("key")) |
|||
if err != nil { |
|||
log.Println(err) |
|||
return |
|||
} |
|||
server := gost.NewProxyServer(node, chain, &tls.Config{Certificates: []tls.Certificate{cert}}) |
|||
log.Fatal(server.Serve()) |
|||
}(serverNode) |
|||
} |
|||
wg.Wait() |
|||
} |
|||
@ -0,0 +1,369 @@ |
|||
// KCP feature is based on https://github.com/xtaci/kcptun
|
|||
|
|||
package gost |
|||
|
|||
import ( |
|||
"crypto/sha1" |
|||
"encoding/json" |
|||
"github.com/golang/glog" |
|||
"github.com/klauspost/compress/snappy" |
|||
"golang.org/x/crypto/pbkdf2" |
|||
"gopkg.in/xtaci/kcp-go.v2" |
|||
"gopkg.in/xtaci/smux.v1" |
|||
"net" |
|||
"os" |
|||
"time" |
|||
) |
|||
|
|||
const ( |
|||
DefaultKCPConfigFile = "kcp.json" |
|||
) |
|||
|
|||
var ( |
|||
SALT = "kcp-go" |
|||
) |
|||
|
|||
type KCPConfig struct { |
|||
Key string `json:"key"` |
|||
Crypt string `json:"crypt"` |
|||
Mode string `json:"mode"` |
|||
MTU int `json:"mtu"` |
|||
SndWnd int `json:"sndwnd"` |
|||
RcvWnd int `json:"rcvwnd"` |
|||
DataShard int `json:"datashard"` |
|||
ParityShard int `json:"parityshard"` |
|||
DSCP int `json:"dscp"` |
|||
NoComp bool `json:"nocomp"` |
|||
AckNodelay bool `json:"acknodelay"` |
|||
NoDelay int `json:"nodelay"` |
|||
Interval int `json:"interval"` |
|||
Resend int `json:"resend"` |
|||
NoCongestion int `json:"nc"` |
|||
SockBuf int `json:"sockbuf"` |
|||
KeepAlive int `json:"keepalive"` |
|||
} |
|||
|
|||
func ParseKCPConfig(configFile string) (*KCPConfig, error) { |
|||
if configFile == "" { |
|||
configFile = DefaultKCPConfigFile |
|||
} |
|||
file, err := os.Open(configFile) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
defer file.Close() |
|||
|
|||
config := &KCPConfig{} |
|||
if err = json.NewDecoder(file).Decode(config); err != nil { |
|||
return nil, err |
|||
} |
|||
return config, nil |
|||
} |
|||
|
|||
func (c *KCPConfig) Init() { |
|||
switch c.Mode { |
|||
case "normal": |
|||
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 0, 30, 2, 1 |
|||
case "fast2": |
|||
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 1, 20, 2, 1 |
|||
case "fast3": |
|||
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 1, 10, 2, 1 |
|||
case "fast": |
|||
fallthrough |
|||
default: |
|||
c.NoDelay, c.Interval, c.Resend, c.NoCongestion = 0, 20, 2, 1 |
|||
} |
|||
} |
|||
|
|||
var ( |
|||
DefaultKCPConfig = &KCPConfig{ |
|||
Key: "it's a secrect", |
|||
Crypt: "aes", |
|||
Mode: "fast", |
|||
MTU: 1350, |
|||
SndWnd: 1024, |
|||
RcvWnd: 1024, |
|||
DataShard: 10, |
|||
ParityShard: 3, |
|||
DSCP: 0, |
|||
NoComp: false, |
|||
AckNodelay: false, |
|||
NoDelay: 0, |
|||
Interval: 40, |
|||
Resend: 0, |
|||
NoCongestion: 0, |
|||
SockBuf: 4194304, |
|||
KeepAlive: 10, |
|||
} |
|||
) |
|||
|
|||
type KCPServer struct { |
|||
Base *ProxyServer |
|||
Config *KCPConfig |
|||
} |
|||
|
|||
func NewKCPServer(base *ProxyServer, config *KCPConfig) *KCPServer { |
|||
return &KCPServer{Base: base, Config: config} |
|||
} |
|||
|
|||
func (s *KCPServer) ListenAndServe() (err error) { |
|||
if s.Config == nil { |
|||
s.Config = DefaultKCPConfig |
|||
} |
|||
s.Config.Init() |
|||
|
|||
ln, err := kcp.ListenWithOptions(s.Base.Node.Addr, |
|||
blockCrypt(s.Config.Key, s.Config.Crypt, SALT), s.Config.DataShard, s.Config.ParityShard) |
|||
if err != nil { |
|||
return err |
|||
} |
|||
if err = ln.SetDSCP(s.Config.DSCP); err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
} |
|||
if err = ln.SetReadBuffer(s.Config.SockBuf); err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
} |
|||
if err = ln.SetWriteBuffer(s.Config.SockBuf); err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
} |
|||
|
|||
for { |
|||
conn, err := ln.AcceptKCP() |
|||
if err != nil { |
|||
glog.V(LWARNING).Infoln(err) |
|||
continue |
|||
} |
|||
|
|||
conn.SetStreamMode(true) |
|||
conn.SetNoDelay(s.Config.NoDelay, s.Config.Interval, s.Config.Resend, s.Config.NoCongestion) |
|||
conn.SetMtu(s.Config.MTU) |
|||
conn.SetWindowSize(s.Config.SndWnd, s.Config.RcvWnd) |
|||
conn.SetACKNoDelay(s.Config.AckNodelay) |
|||
conn.SetKeepAlive(s.Config.KeepAlive) |
|||
|
|||
go s.handleMux(conn) |
|||
} |
|||
} |
|||
|
|||
func (s *KCPServer) handleMux(conn net.Conn) { |
|||
smuxConfig := smux.DefaultConfig() |
|||
smuxConfig.MaxReceiveBuffer = s.Config.SockBuf |
|||
|
|||
glog.V(LINFO).Infof("[kcp] %s - %s", conn.RemoteAddr(), s.Base.Node.Addr) |
|||
|
|||
if !s.Config.NoComp { |
|||
conn = newCompStreamConn(conn) |
|||
} |
|||
|
|||
mux, err := smux.Server(conn, smuxConfig) |
|||
if err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
return |
|||
} |
|||
defer mux.Close() |
|||
|
|||
glog.V(LINFO).Infof("[kcp] %s <-> %s", conn.RemoteAddr(), s.Base.Node.Addr) |
|||
defer glog.V(LINFO).Infof("[kcp] %s >-< %s", conn.RemoteAddr(), s.Base.Node.Addr) |
|||
|
|||
for { |
|||
stream, err := mux.AcceptStream() |
|||
if err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
return |
|||
} |
|||
go s.Base.handleConn(NewKCPConn(conn, stream)) |
|||
} |
|||
} |
|||
|
|||
func blockCrypt(key, crypt, salt string) (block kcp.BlockCrypt) { |
|||
pass := pbkdf2.Key([]byte(key), []byte(salt), 4096, 32, sha1.New) |
|||
|
|||
switch crypt { |
|||
case "tea": |
|||
block, _ = kcp.NewTEABlockCrypt(pass[:16]) |
|||
case "xor": |
|||
block, _ = kcp.NewSimpleXORBlockCrypt(pass) |
|||
case "none": |
|||
block, _ = kcp.NewNoneBlockCrypt(pass) |
|||
case "aes-128": |
|||
block, _ = kcp.NewAESBlockCrypt(pass[:16]) |
|||
case "aes-192": |
|||
block, _ = kcp.NewAESBlockCrypt(pass[:24]) |
|||
case "blowfish": |
|||
block, _ = kcp.NewBlowfishBlockCrypt(pass) |
|||
case "twofish": |
|||
block, _ = kcp.NewTwofishBlockCrypt(pass) |
|||
case "cast5": |
|||
block, _ = kcp.NewCast5BlockCrypt(pass[:16]) |
|||
case "3des": |
|||
block, _ = kcp.NewTripleDESBlockCrypt(pass[:24]) |
|||
case "xtea": |
|||
block, _ = kcp.NewXTEABlockCrypt(pass[:16]) |
|||
case "salsa20": |
|||
block, _ = kcp.NewSalsa20BlockCrypt(pass) |
|||
case "aes": |
|||
fallthrough |
|||
default: // aes
|
|||
block, _ = kcp.NewAESBlockCrypt(pass) |
|||
} |
|||
return |
|||
} |
|||
|
|||
type KCPSession struct { |
|||
conn net.Conn |
|||
session *smux.Session |
|||
} |
|||
|
|||
func DialKCP(addr string, config *KCPConfig) (*KCPSession, error) { |
|||
if config == nil { |
|||
config = DefaultKCPConfig |
|||
} |
|||
config.Init() |
|||
|
|||
kcpconn, err := kcp.DialWithOptions(addr, |
|||
blockCrypt(config.Key, config.Crypt, SALT), config.DataShard, config.ParityShard) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
|
|||
kcpconn.SetStreamMode(true) |
|||
kcpconn.SetNoDelay(config.NoDelay, config.Interval, config.Resend, config.NoCongestion) |
|||
kcpconn.SetWindowSize(config.SndWnd, config.RcvWnd) |
|||
kcpconn.SetMtu(config.MTU) |
|||
kcpconn.SetACKNoDelay(config.AckNodelay) |
|||
kcpconn.SetKeepAlive(config.KeepAlive) |
|||
|
|||
if err := kcpconn.SetDSCP(config.DSCP); err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
} |
|||
if err := kcpconn.SetReadBuffer(config.SockBuf); err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
} |
|||
if err := kcpconn.SetWriteBuffer(config.SockBuf); err != nil { |
|||
glog.V(LWARNING).Infoln("[kcp]", err) |
|||
} |
|||
|
|||
// stream multiplex
|
|||
smuxConfig := smux.DefaultConfig() |
|||
smuxConfig.MaxReceiveBuffer = config.SockBuf |
|||
var conn net.Conn = kcpconn |
|||
if !config.NoComp { |
|||
conn = newCompStreamConn(kcpconn) |
|||
} |
|||
session, err := smux.Client(conn, smuxConfig) |
|||
if err != nil { |
|||
conn.Close() |
|||
return nil, err |
|||
} |
|||
return &KCPSession{conn: conn, session: session}, nil |
|||
} |
|||
|
|||
func (session *KCPSession) GetConn() (*KCPConn, error) { |
|||
stream, err := session.session.OpenStream() |
|||
if err != nil { |
|||
session.Close() |
|||
return nil, err |
|||
} |
|||
return NewKCPConn(session.conn, stream), nil |
|||
} |
|||
|
|||
func (session *KCPSession) Close() error { |
|||
return session.session.Close() |
|||
} |
|||
|
|||
func (session *KCPSession) IsClosed() bool { |
|||
return session.session.IsClosed() |
|||
} |
|||
|
|||
func (session *KCPSession) NumStreams() int { |
|||
return session.session.NumStreams() |
|||
} |
|||
|
|||
type KCPConn struct { |
|||
conn net.Conn |
|||
stream *smux.Stream |
|||
} |
|||
|
|||
func NewKCPConn(conn net.Conn, stream *smux.Stream) *KCPConn { |
|||
return &KCPConn{conn: conn, stream: stream} |
|||
} |
|||
|
|||
func (c *KCPConn) Read(b []byte) (n int, err error) { |
|||
return c.stream.Read(b) |
|||
} |
|||
|
|||
func (c *KCPConn) Write(b []byte) (n int, err error) { |
|||
return c.stream.Write(b) |
|||
} |
|||
|
|||
func (c *KCPConn) Close() error { |
|||
return c.stream.Close() |
|||
} |
|||
|
|||
func (c *KCPConn) LocalAddr() net.Addr { |
|||
return c.conn.LocalAddr() |
|||
} |
|||
|
|||
func (c *KCPConn) RemoteAddr() net.Addr { |
|||
return c.conn.RemoteAddr() |
|||
} |
|||
|
|||
func (c *KCPConn) SetDeadline(t time.Time) error { |
|||
return c.conn.SetDeadline(t) |
|||
} |
|||
|
|||
func (c *KCPConn) SetReadDeadline(t time.Time) error { |
|||
return c.conn.SetReadDeadline(t) |
|||
} |
|||
|
|||
func (c *KCPConn) SetWriteDeadline(t time.Time) error { |
|||
return c.conn.SetWriteDeadline(t) |
|||
} |
|||
|
|||
type compStreamConn struct { |
|||
conn net.Conn |
|||
w *snappy.Writer |
|||
r *snappy.Reader |
|||
} |
|||
|
|||
func newCompStreamConn(conn net.Conn) *compStreamConn { |
|||
c := new(compStreamConn) |
|||
c.conn = conn |
|||
c.w = snappy.NewBufferedWriter(conn) |
|||
c.r = snappy.NewReader(conn) |
|||
return c |
|||
} |
|||
|
|||
func (c *compStreamConn) Read(b []byte) (n int, err error) { |
|||
return c.r.Read(b) |
|||
} |
|||
|
|||
func (c *compStreamConn) Write(b []byte) (n int, err error) { |
|||
n, err = c.w.Write(b) |
|||
err = c.w.Flush() |
|||
return n, err |
|||
} |
|||
|
|||
func (c *compStreamConn) Close() error { |
|||
return c.conn.Close() |
|||
} |
|||
|
|||
func (c *compStreamConn) LocalAddr() net.Addr { |
|||
return c.conn.LocalAddr() |
|||
} |
|||
|
|||
func (c *compStreamConn) RemoteAddr() net.Addr { |
|||
return c.conn.RemoteAddr() |
|||
} |
|||
|
|||
func (c *compStreamConn) SetDeadline(t time.Time) error { |
|||
return c.conn.SetDeadline(t) |
|||
} |
|||
|
|||
func (c *compStreamConn) SetReadDeadline(t time.Time) error { |
|||
return c.conn.SetReadDeadline(t) |
|||
} |
|||
|
|||
func (c *compStreamConn) SetWriteDeadline(t time.Time) error { |
|||
return c.conn.SetWriteDeadline(t) |
|||
} |
|||
@ -0,0 +1,80 @@ |
|||
package gost |
|||
|
|||
import ( |
|||
"bufio" |
|||
"crypto/tls" |
|||
"github.com/golang/glog" |
|||
"github.com/lucas-clemente/quic-go/h2quic" |
|||
"io" |
|||
"net/http" |
|||
"net/http/httputil" |
|||
) |
|||
|
|||
type QuicServer struct { |
|||
Base *ProxyServer |
|||
Handler http.Handler |
|||
TLSConfig *tls.Config |
|||
} |
|||
|
|||
func NewQuicServer(base *ProxyServer) *QuicServer { |
|||
return &QuicServer{Base: base} |
|||
} |
|||
|
|||
func (s *QuicServer) ListenAndServeTLS(config *tls.Config) error { |
|||
server := &h2quic.Server{ |
|||
Server: &http.Server{ |
|||
Addr: s.Base.Node.Addr, |
|||
Handler: s.Handler, |
|||
TLSConfig: config, |
|||
}, |
|||
} |
|||
if server.Handler == nil { |
|||
server.Handler = http.HandlerFunc(s.HandleRequest) |
|||
} |
|||
return server.ListenAndServe() |
|||
} |
|||
|
|||
func (s *QuicServer) HandleRequest(w http.ResponseWriter, req *http.Request) { |
|||
target := req.Host |
|||
glog.V(LINFO).Infof("[quic] %s %s - %s %s", req.Method, req.RemoteAddr, target, req.Proto) |
|||
|
|||
if glog.V(LDEBUG) { |
|||
dump, _ := httputil.DumpRequest(req, false) |
|||
glog.Infoln(string(dump)) |
|||
} |
|||
|
|||
c, err := s.Base.Chain.Dial(target) |
|||
if err != nil { |
|||
glog.V(LWARNING).Infof("[quic] %s -> %s : %s", req.RemoteAddr, target, err) |
|||
w.WriteHeader(http.StatusServiceUnavailable) |
|||
return |
|||
} |
|||
defer c.Close() |
|||
|
|||
glog.V(LINFO).Infof("[quic] %s <-> %s", req.RemoteAddr, target) |
|||
|
|||
req.Header.Set("Connection", "Keep-Alive") |
|||
if err = req.Write(c); err != nil { |
|||
glog.V(LWARNING).Infof("[quic] %s -> %s : %s", req.RemoteAddr, target, err) |
|||
return |
|||
} |
|||
|
|||
resp, err := http.ReadResponse(bufio.NewReader(c), req) |
|||
if err != nil { |
|||
glog.V(LWARNING).Infoln(err) |
|||
return |
|||
} |
|||
defer resp.Body.Close() |
|||
|
|||
for k, v := range resp.Header { |
|||
for _, vv := range v { |
|||
w.Header().Add(k, vv) |
|||
} |
|||
} |
|||
w.WriteHeader(resp.StatusCode) |
|||
if _, err := io.Copy(flushWriter{w}, resp.Body); err != nil { |
|||
glog.V(LWARNING).Infof("[quic] %s <- %s : %s", req.RemoteAddr, target, err) |
|||
} |
|||
|
|||
glog.V(LINFO).Infof("[quic] %s >-< %s", req.RemoteAddr, target) |
|||
} |
|||
Loading…
Reference in new issue