func init() {
proxyTransports["http"] = func(proxyURL *url.URL) (*http.Transport, error) {
return &http.Transport{
Proxy: func(req *http.Request) (*url.URL, error) {
return proxyURL, nil
},
}, nil
}
proxyTransports["socks5"] = func(proxyURL *url.URL) (*http.Transport, error) {
ph, err := proxy.FromURL(proxyURL, proxy.Direct)
if err != nil {
return nil, err
}
return &http.Transport{
Dial: ph.Dial,
}, nil
}
proxyTransports["socks4"] = func(proxyURL *url.URL) (*http.Transport, error) {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS4A, proxyURL.Host)
return &http.Transport{
Dial: dialSocksProxy,
}, nil
}
proxyTransports["socks4a"] = func(proxyURL *url.URL) (*http.Transport, error) {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS4A, proxyURL.Host)
return &http.Transport{
Dial: dialSocksProxy,
}, nil
}
//shadowsocks
proxyTransports["ss"] = func(proxyURL *url.URL) (*http.Transport, error) {
if proxyURL.User == nil {
return nil, fmt.Errorf("wrong shadowsocks uri,need method and passwd")
}
psw, _ := proxyURL.User.Password()
cipher, err := ss.NewCipher(proxyURL.User.Username(), psw)
if err != nil {
return nil, err
}
serverAddr := proxyURL.Host
return &http.Transport{
Dial: func(_, addr string) (net.Conn, error) {
return ss.Dial(addr, serverAddr, cipher.Copy())
},
// DialTLS:func(_, addr string) (net.Conn, error) {
// return ss.Dial(addr, serverAddr, cipher.Copy())
// },
}, nil
}
}
func (s *Scraper) GetHTTPClient() *http.Client {
if s.Opt.Proxy.UseProxy == true && s.Opt.Proxy.SocksIP != "" {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, s.Opt.Proxy.SocksIP)
transport := &http.Transport{Dial: dialSocksProxy}
return &http.Client{Transport: transport}
}
return &http.Client{}
}
func NewClient(e *Env, config *ClientConfig, needCookie bool) *Client {
var jar *cookiejar.Jar
if needCookie && (config == nil || config.UseCookies) && e.GetTorMode().UseCookies() {
jar, _ = cookiejar.New(nil)
}
var timeout time.Duration
// from http.DefaultTransport;
//
// TODO: change this back (see comment below) to allow
// shared Transport after we switch to go1.7
xprt := http.Transport{
Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
TLSHandshakeTimeout: 10 * time.Second,
ExpectContinueTimeout: 1 * time.Second,
}
// This disables HTTP/2. There's a bug introduced between (go1.6, go1.6.3]
// that makes client.Get hang on certain HTTP/2 servers. See CORE-3441 for
// details.
//
// TODO: remove this after the bug is fixed.
xprt.TLSNextProto = make(
map[string]func(authority string, c *tls.Conn) http.RoundTripper)
if (config != nil && config.RootCAs != nil) || e.GetTorMode().Enabled() {
if config != nil && config.RootCAs != nil {
xprt.TLSClientConfig = &tls.Config{RootCAs: config.RootCAs}
}
if e.GetTorMode().Enabled() {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, e.GetTorProxy())
xprt.Dial = dialSocksProxy
} else {
xprt.Proxy = http.ProxyFromEnvironment
}
}
if config == nil || config.Timeout == 0 {
timeout = HTTPDefaultTimeout
} else {
timeout = config.Timeout
}
ret := &Client{
cli: &http.Client{Timeout: timeout},
config: config,
}
if jar != nil {
ret.cli.Jar = jar
}
ret.cli.Transport = &xprt
return ret
}
// 创建连接
func GenConn(socketAddr string, useProxy bool) (conn net.Conn, err error) {
proxy := GetProxy()
if useProxy == false || proxy == "" {
conn, err = net.Dial("tcp", socketAddr)
} else {
conn, err = socks.DialSocksProxy(socks.SOCKS5, proxy)("", socketAddr)
}
return
}
func clientForProxy(proxy *url.URL, timeout time.Duration, agent string) Client {
proto := proxyTypeMap[proxy.Scheme]
dialer := socks.DialSocksProxy(proto, proxy.Host)
cl := &httpClient{
Client: http.Client{
Transport: &http.Transport{
Dial: dialer,
},
Timeout: timeout,
},
UserAgent: agent}
return cl
}
func torexitip() string {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, "127.0.0.1:9050")
tr := &http.Transport{Dial: dialSocksProxy}
httpClient := &http.Client{Transport: tr}
req, _ := http.NewRequest("GET", "http://myexternalip.com/raw", nil)
res, err := httpClient.Do(req)
if err != nil {
}
defer res.Body.Close()
contents, err := ioutil.ReadAll(res.Body)
if err != nil {
}
return string(contents)
}
//
// FUNCAO GETANONYBT - BRUTEFORCE
//
func getanonybt(url string, randpath string) string {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, "127.0.0.1:9050")
tr := &http.Transport{Dial: dialSocksProxy}
httpClient := &http.Client{Transport: tr}
req, _ := http.NewRequest("GET", url, nil)
req.SetBasicAuth(randpath, randpath)
iptor := torexitip()
log.Printf("GETANONYBT path: %s with address: %s", randpath, iptor)
req.Header.Set("User-Agent", readfile("/go/src/torroulette/public/file/useragents"))
res, err := httpClient.Do(req)
if err != nil {
key := "1"
return key
}
defer res.Body.Close()
key := "0"
return key
}
func testSocks5Internet(addr string) (err error) {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, addr)
httpClient := &http.Client{
Transport: &http.Transport{
Dial: dialSocksProxy,
DisableKeepAlives: true,
ResponseHeaderTimeout: time.Duration(time.Second * 5),
},
}
resp, err := httpClient.Get("http://ip.appspot.com")
if err != nil {
return
}
defer resp.Body.Close()
_, err = ioutil.ReadAll(resp.Body)
if err != nil {
return
}
return
}
func testSocks5Internet(addr string) (err error) {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, addr)
httpClient := &http.Client{
Transport: &http.Transport{
Dial: dialSocksProxy,
DisableKeepAlives: true,
ResponseHeaderTimeout: connectionManagerTimings.SimpleHTTPTestResponseHeaderTimeout,
},
Timeout: connectionManagerTimings.SimpleHTTPTestRequestTimeout,
}
resp, err := httpClient.Get("https://alkasir.com/ping")
if err != nil {
return err
}
defer resp.Body.Close()
_, err = ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
return
}
func testSocks5Internet(addr string) (err error) {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, addr)
httpClient := &http.Client{
Transport: &http.Transport{
Dial: dialSocksProxy,
DisableKeepAlives: true,
ResponseHeaderTimeout: 10 * time.Second,
},
Timeout: 20 * time.Second,
}
resp, err := httpClient.Get("https://alkasir.com/ping")
if err != nil {
return
}
defer resp.Body.Close()
_, err = ioutil.ReadAll(resp.Body)
if err != nil {
return
}
return
}
func NewClient(e *Env, config *ClientConfig, needCookie bool) *Client {
var jar *cookiejar.Jar
if needCookie && (config == nil || config.UseCookies) && e.GetTorMode().UseCookies() {
jar, _ = cookiejar.New(nil)
}
var xprt *http.Transport
var timeout time.Duration
if (config != nil && config.RootCAs != nil) || e.GetTorMode().Enabled() {
xprt = &http.Transport{}
if config != nil && config.RootCAs != nil {
xprt.TLSClientConfig = &tls.Config{RootCAs: config.RootCAs}
}
if e.GetTorMode().Enabled() {
dialSocksProxy := socks.DialSocksProxy(socks.SOCKS5, e.GetTorProxy())
xprt.Dial = dialSocksProxy
} else {
xprt.Proxy = http.ProxyFromEnvironment
}
}
if config == nil || config.Timeout == 0 {
timeout = HTTPDefaultTimeout
} else {
timeout = config.Timeout
}
ret := &Client{
cli: &http.Client{Timeout: timeout},
config: config,
}
if jar != nil {
ret.cli.Jar = jar
}
if xprt != nil {
ret.cli.Transport = xprt
}
return ret
}
// Dial returns a
func (t *TransportService) Dial() Dialer {
response := t.Service.Response
return socks.DialSocksProxy(socks.SOCKS5, response["bindaddr"])
}
func TestSocksConformance(t *testing.T) {
assert := assert.On(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
defer tcpServer.Close()
authPort := pickPort()
noAuthPort := pickPort()
serverConfig := &core.Config{
Inbound: []*proxyman.InboundHandlerConfig{
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: v2net.SinglePortRange(authPort),
Listen: v2net.NewIPOrDomain(v2net.LocalHostIP),
}),
ProxySettings: serial.ToTypedMessage(&socks.ServerConfig{
AuthType: socks.AuthType_PASSWORD,
Accounts: map[string]string{
"Test Account": "Test Password",
},
Address: v2net.NewIPOrDomain(v2net.LocalHostIP),
UdpEnabled: false,
}),
},
{
ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
PortRange: v2net.SinglePortRange(noAuthPort),
Listen: v2net.NewIPOrDomain(v2net.LocalHostIP),
}),
ProxySettings: serial.ToTypedMessage(&socks.ServerConfig{
AuthType: socks.AuthType_NO_AUTH,
Accounts: map[string]string{
"Test Account": "Test Password",
},
Address: v2net.NewIPOrDomain(v2net.LocalHostIP),
UdpEnabled: false,
}),
},
},
Outbound: []*proxyman.OutboundHandlerConfig{
{
ProxySettings: serial.ToTypedMessage(&freedom.Config{}),
},
},
}
assert.Error(InitializeServerConfig(serverConfig)).IsNil()
{
noAuthDialer, err := xproxy.SOCKS5("tcp", v2net.TCPDestination(v2net.LocalHostIP, noAuthPort).NetAddr(), nil, xproxy.Direct)
assert.Error(err).IsNil()
conn, err := noAuthDialer.Dial("tcp", dest.NetAddr())
assert.Error(err).IsNil()
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
}
{
authDialer, err := xproxy.SOCKS5("tcp", v2net.TCPDestination(v2net.LocalHostIP, authPort).NetAddr(), &xproxy.Auth{User: "******", Password: "******"}, xproxy.Direct)
assert.Error(err).IsNil()
conn, err := authDialer.Dial("tcp", dest.NetAddr())
assert.Error(err).IsNil()
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
}
{
dialer := socks4.DialSocksProxy(socks4.SOCKS4, v2net.TCPDestination(v2net.LocalHostIP, noAuthPort).NetAddr())
conn, err := dialer("tcp", dest.NetAddr())
assert.Error(err).IsNil()
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
}
{
dialer := socks4.DialSocksProxy(socks4.SOCKS4A, v2net.TCPDestination(v2net.LocalHostIP, noAuthPort).NetAddr())
conn, err := dialer("tcp", v2net.TCPDestination(v2net.LocalHostDomain, tcpServer.Port).NetAddr())
assert.Error(err).IsNil()
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
}
CloseAllServers()
}
