golang实现http，socks5代理扫描工具

package proxy

import (
	"fmt"
	"net/http"
	"net/url"
	"time"
)

type HttpProxy struct {
}

func (HttpProxy) IsProxy(proxyIp string, proxyPort int) (isProxy bool, err error) {
	proxyUrl := fmt.Sprintf("http://%s:%d", proxyIp, proxyPort)
	proxy, err := url.Parse(proxyUrl)
	if err != nil {
		return false, err
	}
	netTransport := &http.Transport{
		Proxy: http.ProxyURL(proxy),
	}
	client := &http.Client{
		Timeout:   time.Second * 20,  //设置连接超时时间
		Transport: netTransport,
	}
	return CheckProxy(client)
}

package proxy

import (
	"context"
	"fmt"
	"golang.org/x/net/proxy"
	"net"
	"net/http"
	"time"
)

type SocksProxy struct {
}

func (SocksProxy) IsProxy(proxyIp string, proxyPort int) (isProxy bool, err error) {
	proxyAddr := fmt.Sprintf("%s:%d", proxyIp, proxyPort)
	dialSocksProxy, err := proxy.SOCKS5("tcp", proxyAddr, nil, proxy.Direct)
	if err != nil {
		return false, nil
	}
	netTransport := &http.Transport{DialContext: func(ctx context.Context, network, addr string) (conn net.Conn, e error) {
		c, e := dialSocksProxy.Dial(network, addr)
		return c, e
	}}
	client := &http.Client{
		Timeout:   time.Second * 10,
		Transport: netTransport,
	}
	return CheckProxy(client)
}

package proxy

import (
	"io/ioutil"
	"net/http"
	"strings"
)

const TestUrl = "http://www.baidu.com"

type Proxyer interface {
	IsProxy(proxyIp string, proxyPort int) (isProxy bool, err error)
}

func CheckProxy(client *http.Client) (isProxy bool, err error){
	res, err := client.Get(TestUrl)
	if err != nil {
		return false, err
	} else {
		defer res.Body.Close()
		if res.StatusCode == 200 {
			body, err := ioutil.ReadAll(res.Body)
			if err == nil && strings.Contains(string(body), "baidu") {
				return true, nil
			} else {
				return false, err
			}
		} else {
			return false, nil
		}
	}
}

package proxy

import (
	"github.com/elazarl/goproxy"
	"log"
	"net/http"
	"testing"
	"time"
)

func TestCheckHttpProxy(t *testing.T) {
	go func() {
		proxy := goproxy.NewProxyHttpServer()
		proxy.Verbose = true
		log.Fatal(http.ListenAndServe(":8080", proxy))
	}()
	time.Sleep(time.Second * 2)
	isProxy, err := HttpProxy{}.IsProxy("127.0.0.1", 8080)
	if !isProxy {
		t.Error("should be a proxy", err)
	}
}

package proxy

import (
	"github.com/armon/go-socks5"
	"testing"
	"time"
)

func TestIsSocksProxy(t *testing.T) {
	go func() {
		conf := &socks5.Config{}
		server, err := socks5.New(conf)
		if err != nil {
			panic(err)
		}
		if err := server.ListenAndServe("tcp", "127.0.0.1:8002"); err != nil {
			panic(err)
		}
	}()
	time.Sleep(time.Second*2)
	isProxy, err := SocksProxy{}.IsProxy("127.0.0.1", 8002)
	if !isProxy {
		t.Error("should be a proxy", err)
	}
}

package main

import (
	"fmt"
	"sync"
	"time"
)
import "scanproxy/proxy"

var (
	Threads = make(chan int, 500) //控制在500以内
)

func main() {
	var start = 8000
	var end = 10000
	var proxyIp = "183.30.204.91"
	var now = time.Now().Unix()
	var Map = make(map[int]bool)
	var waitGroup = sync.WaitGroup{}
	for port := start; port < end; port++ {
		Threads <- 1
		go func(port int) {
			waitGroup.Add(1)
			defer waitGroup.Add(-1)
			isProxy, err := proxy.HttpProxy{}.IsProxy(proxyIp, port)
			if isProxy {
				fmt.Printf("%s:%d\n", proxyIp, port)
				Map[port] = true
			}
			if err != nil {
				fmt.Println(err)
			}
			<-Threads
		}(port)
	}
	waitGroup.Wait()
	fmt.Printf("用时%d秒\n",time.Now().Unix()-now)
	fmt.Println(Map)
}

client := &http.Client{
		Timeout:   time.Second * 20,
		Transport: netTransport,
	}

183.30.204.91:9999
Get http://www.baidu.com: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
Get http://www.baidu.com: net/http: request canceled (Client.Timeout exceeded while awaiting headers)
用时5秒
map[9999:true]