prox5/validator_engine.go

package pxndscvm

import (
	"bytes"
	"crypto/tls"
	"errors"
	"io"
	"io/ioutil"
	"net"
	"net/http"
//	"net/url"
	"sync/atomic"
	"time"

	"golang.org/x/net/proxy"
	"h12.io/socks"
)

func (s *Swamp) prepHTTP() (*http.Client, *http.Transport, *http.Request, error) {
	req, err := http.NewRequest("GET", s.GetRandomEndpoint(), bytes.NewBuffer([]byte("")))
	if err != nil {
		return nil, nil, nil, err
	}
	headers := make(map[string]string)
	headers["User-Agent"] = s.RandomUserAgent()
	headers["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"
	headers["Accept-Language"] = "en-US,en;q=0.5"
	headers["'Accept-Encoding'"] = "gzip, deflate, br"
	headers["Connection"] = "keep-alive"
	for header, value := range headers {
		req.Header.Set(header, value)
	}
	var client *http.Client
	var transporter = &http.Transport{
		DisableKeepAlives:   true,
		TLSClientConfig:     &tls.Config{InsecureSkipVerify: true},
		TLSHandshakeTimeout: time.Duration(s.GetValidationTimeout()) * time.Second,
	}
	
	return client, transporter, req, err
}

func (s *Swamp) checkHTTP(sock *Proxy) (string, error) {
	var (
		client *http.Client
		transporter *http.Transport
		req *http.Request
		err error
	)

	if client, transporter, req, err = s.prepHTTP(); err != nil {
		return "", err
	}

	var t int
	switch sock.Proto {
	case "5":
		t = socks.SOCKS5
	case "4":
		t = socks.SOCKS4
	case "4a":
		t = socks.SOCKS4A
	}

	var dialSocks = socks.DialSocksProxy(t, sock.Endpoint)
	var transportDialer = dialSocks
	if sock.Proto == "none" {
		transportDialer = proxy.Direct.Dial
	}

	//if sock.Proto != "http" {
	transporter.Dial = transportDialer

	//} else {
	//	if purl, err := url.Parse("http://" + sock.Endpoint); err == nil {
	//		transporter.Proxy = http.ProxyURL(purl)
	//	} else {
	//		return "", err
	//	}
	//}

	client = &http.Client{
		Transport: transporter,
		Timeout:   time.Duration(s.swampopt.validationTimeout) * time.Second,
	}

	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}

	defer func(Body io.ReadCloser) {
		err := Body.Close()
		if err != nil {
			panic(err)
		}
	}(resp.Body)

	rbody, err := ioutil.ReadAll(resp.Body)
	return string(rbody), err
}

func (s *Swamp) singleProxyCheck(sock *Proxy) error {
	s.Stats.Checked++
	if _, err := net.DialTimeout("tcp", sock.Endpoint, time.Duration(s.GetValidationTimeout())*time.Second); err != nil {
		s.badProx.Check(sock)
		return err
	}

	resp, err := s.checkHTTP(sock)
	if err != nil {
		s.badProx.Check(sock)
		return err
	}

	if newip := net.ParseIP(resp); newip == nil {
		s.badProx.Check(sock)
		return errors.New("bad response from http request: " + resp)
	}

	sock.ProxiedIP = resp
	return nil
}

func (sock *Proxy) validate() {
	var sversions = []string{"4", "5", "4a"}

	s := sock.parent
	if s.useProx.Check(sock) {
		s.dbgPrint(ylw + "useProx ratelimited: " + sock.Endpoint + rst)
		atomic.StoreUint32(&sock.lock, stateUnlocked)
		return
	}

	// determined as bad, won't try again until it expires from that cache
	if s.badProx.Peek(sock) {
		s.dbgPrint(ylw + "badProx ratelimited: " + sock.Endpoint + rst)
		atomic.StoreUint32(&sock.lock, stateUnlocked)
		return
	}

	// try to use the proxy with all 3 SOCKS versions
	var good = false
	for _, sver := range sversions {
		if s.Status == Paused {
			return
		}

		sock.Proto = sver
		if err := s.singleProxyCheck(sock); err == nil {
//			if sock.Proto != "http" {
			s.dbgPrint(grn + "verified " + sock.Endpoint + " as SOCKS" + sver + rst)
//			} else {
//				s.dbgPrint(ylw + "verified " + sock.Endpoint + " as http (not usable yet)" + rst)
//			}
			good = true
			break
		}
	}

	if !good {
		s.dbgPrint(red + "failed to verify: " + sock.Endpoint)
		sock.TimesBad++
		s.badProx.Check(sock)
		atomic.StoreUint32(&sock.lock, stateUnlocked)
		return
	}

	sock.TimesValidated++
	sock.LastVerified = time.Now()
	atomic.StoreUint32(&sock.lock, stateUnlocked)

	switch sock.Proto {
	case "4":
		go func() {
			s.Stats.v4()
			s.ValidSocks4 <- sock
		}()
		return
	case "4a":
		go func() {
			s.Stats.v4a()
			s.ValidSocks4a <- sock
		}()
		return
	case "5":
		go func() {
			s.Stats.v5()
			s.ValidSocks5 <- sock
		}()
		return
	default:
		return
	}
}