Update documentation and code to follow coding convention

ProjectDiscovery code usually follows the rule "Words in names
that are initialisms or acronyms (e.g., URL and NATO) should have
the same case." (defined in https://google.github.io/styleguide/
go/decisions.html#initialisms) SOCKS5 is most commonly written in
all-caps, just like HTTP.

This commit updates the documentation and code to all use the same
style when refering to SOCKS5 as well as adhere to the coding
convention. This commit also updates some other style errors.

Signed-off-by: MJ Kim <mjkim610@gmail.com>

Author: mjkim610

README.md

@@ -22,7 +22,7 @@
   <a href="https://discord.gg/projectdiscovery">Join Discord</a>
 </p>
 
-Swiss Army Knife Proxy for rapid deployments. Supports multiple operations such as request/response dump, filtering and manipulation via DSL language, upstream HTTP/Socks5 proxy.
+Swiss Army Knife Proxy for rapid deployments. Supports multiple operations such as request/response dump, filtering and manipulation via DSL language, upstream HTTP/SOCKS5 proxy.
 Additionally, a replay utility allows to import the dumped traffic (request/responses with correct domain name) into BurpSuite or any other proxy by simply setting the upstream proxy to proxify.
 
 # Features
@@ -60,7 +60,7 @@ proxify -h
 This will display help for the tool. Here are all the switches it supports.
 
 ```console
-Swiss Army Knife Proxy for rapid deployments. Supports multiple operations such as request/response dump,filtering and manipulation via DSL language, upstream HTTP/Socks5 proxy
+Swiss Army Knife Proxy for rapid deployments. Supports multiple operations such as request/response dump,filtering and manipulation via DSL language, upstream HTTP/SOCKS5 proxy
 
 Usage:
   ./proxify [flags]

internal/runner/options.go

@@ -37,7 +37,7 @@ type Options struct {
 	Verbosity                   types.Verbosity
 	Version                     bool
 	ListenAddrHTTP              string
-	ListenAddrSocks5            string
+	ListenAddrSOCKS5            string
 	ListenDNSAddr               string
 	DNSMapping                  string              // DNSMapping contains user provided hosts
 	DNSFallbackResolver         string              // Listen DNS Ip and port (ip:port)
@@ -47,7 +47,7 @@ type Options struct {
 	ResponseDSL                 goflags.StringSlice // Response Filter DSL
 	ResponseMatchReplaceDSL     goflags.StringSlice // Request Match-Replace DSL
 	UpstreamHTTPProxies         goflags.StringSlice // Upstream HTTP comma separated Proxies (e.g. http://proxyip:proxyport)
-	UpstreamSocks5Proxies       goflags.StringSlice // Upstream SOCKS5 comma separated Proxies (e.g. socks5://proxyip:proxyport)
+	UpstreamSOCKS5Proxies       goflags.StringSlice // Upstream SOCKS5 comma separated Proxies (e.g. socks5://proxyip:proxyport)
 	UpstreamProxyRequestsNumber int                 // Number of requests before switching upstream proxy
 	DumpRequest                 bool                // Dump requests in separate files
 	DumpResponse                bool                // Dump responses in separate files
@@ -71,7 +71,7 @@ func ParseOptions() (*Options, error) {
 	options := &Options{}
 
 	flagSet := goflags.NewFlagSet()
-	flagSet.SetDescription(`Swiss Army Knife Proxy for rapid deployments. Supports multiple operations such as request/response dump,filtering and manipulation via DSL language, upstream HTTP/Socks5 proxy`)
+	flagSet.SetDescription(`Swiss Army Knife Proxy for rapid deployments. Supports multiple operations such as request/response dump,filtering and manipulation via DSL language, upstream HTTP/SOCKS5 proxy`)
 
 	flagSet.CreateGroup("output", "Output",
 		// Todo:	flagSet.BoolVar(&options.Dump, "dump", true, "Dump HTTP requests/response to output file"),
@@ -98,15 +98,15 @@ func ParseOptions() (*Options, error) {
 
 	flagSet.CreateGroup("network", "Network",
 		flagSet.StringVarP(&options.ListenAddrHTTP, "http-addr", "ha", "127.0.0.1:8888", "Listening HTTP IP and Port address (ip:port)"),
-		flagSet.StringVarP(&options.ListenAddrSocks5, "socks-addr", "sa", "127.0.0.1:10080", "Listening SOCKS IP and Port address (ip:port)"),
+		flagSet.StringVarP(&options.ListenAddrSOCKS5, "socks-addr", "sa", "127.0.0.1:10080", "Listening SOCKS IP and Port address (ip:port)"),
 		flagSet.StringVarP(&options.ListenDNSAddr, "dns-addr", "da", "", "Listening DNS IP and Port address (ip:port)"),
 		flagSet.StringVarP(&options.DNSMapping, "dns-mapping", "dm", "", "Domain to IP DNS mapping (eg domain:ip,domain:ip,..)"),
 		flagSet.StringVarP(&options.DNSFallbackResolver, "resolver", "r", "", "Custom DNS resolvers to use (ip:port)"),
 	)
 
 	flagSet.CreateGroup("proxy", "Proxy",
 		flagSet.StringSliceVarP(&options.UpstreamHTTPProxies, "http-proxy", "hp", nil, "Upstream HTTP Proxies (eg http://proxy-ip:proxy-port)", goflags.NormalizedStringSliceOptions),
-		flagSet.StringSliceVarP(&options.UpstreamSocks5Proxies, "socks5-proxy", "sp", nil, "Upstream SOCKS5 Proxies (eg socks5://proxy-ip:proxy-port)", goflags.NormalizedStringSliceOptions),
+		flagSet.StringSliceVarP(&options.UpstreamSOCKS5Proxies, "socks5-proxy", "sp", nil, "Upstream SOCKS5 Proxies (eg socks5://proxy-ip:proxy-port)", goflags.NormalizedStringSliceOptions),
 		flagSet.IntVar(&options.UpstreamProxyRequestsNumber, "c", 1, "Number of requests before switching to the next upstream proxy"),
 	)
 

internal/runner/runner.go

@@ -37,15 +37,15 @@ func NewRunner(options *Options) (*Runner, error) {
 		CertCacheSize:               options.CertCacheSize,
 		Verbosity:                   options.Verbosity,
 		ListenAddrHTTP:              options.ListenAddrHTTP,
-		ListenAddrSocks5:            options.ListenAddrSocks5,
+		ListenAddrSOCKS5:            options.ListenAddrSOCKS5,
 		OutputFile:                  options.OutputFile,
 		OutputFormat:                options.OutputFormat,
 		OutputDirectory:             options.OutputDirectory,
 		OutputHar:                   options.OutputHar,
 		RequestDSL:                  options.RequestDSL,
 		ResponseDSL:                 options.ResponseDSL,
 		UpstreamHTTPProxies:         options.UpstreamHTTPProxies,
-		UpstreamSock5Proxies:        options.UpstreamSocks5Proxies,
+		UpstreamSOCKS5Proxies:       options.UpstreamSOCKS5Proxies,
 		ListenDNSAddr:               options.ListenDNSAddr,
 		DNSMapping:                  options.DNSMapping,
 		DNSFallbackResolver:         options.DNSFallbackResolver,
@@ -91,8 +91,8 @@ func (r *Runner) Run() error {
 	if r.options.ListenAddrHTTP != "" {
 		gologger.Info().Msgf("HTTP Proxy Listening on %s\n", r.options.ListenAddrHTTP)
 	}
-	if r.options.ListenAddrSocks5 != "" {
-		gologger.Info().Msgf("Socks5 Proxy Listening on %s\n", r.options.ListenAddrSocks5)
+	if r.options.ListenAddrSOCKS5 != "" {
+		gologger.Info().Msgf("SOCKS5 Proxy Listening on %s\n", r.options.ListenAddrSOCKS5)
 	}
 
 	if r.options.OutputFile != "" {
@@ -112,8 +112,8 @@ func (r *Runner) Run() error {
 
 	if len(r.options.UpstreamHTTPProxies) > 0 {
 		gologger.Info().Msgf("Using upstream HTTP proxies: %s\n", r.options.UpstreamHTTPProxies)
-	} else if len(r.options.UpstreamSocks5Proxies) > 0 {
-		gologger.Info().Msgf("Using upstream SOCKS5 proxies: %s\n", r.options.UpstreamSocks5Proxies)
+	} else if len(r.options.UpstreamSOCKS5Proxies) > 0 {
+		gologger.Info().Msgf("Using upstream SOCKS5 proxies: %s\n", r.options.UpstreamSOCKS5Proxies)
 	}
 
 	if r.options.DNSMapping != "" {

proxy.go

@@ -52,15 +52,15 @@ type Options struct {
 	CertCacheSize               int
 	Directory                   string
 	ListenAddrHTTP              string
-	ListenAddrSocks5            string
+	ListenAddrSOCKS5            string
 	OutputDirectory             string
 	OutputFile                  string
 	OutputFormat                string
 	OutputHar                   string
 	RequestDSL                  []string
 	ResponseDSL                 []string
 	UpstreamHTTPProxies         []string
-	UpstreamSock5Proxies        []string
+	UpstreamSOCKS5Proxies       []string
 	ListenDNSAddr               string
 	DNSMapping                  string
 	DNSFallbackResolver         string
@@ -81,12 +81,12 @@ type Proxy struct {
 	options      *Options
 	logger       *logger.Logger
 	httpProxy    *martian.Proxy
-	socks5proxy  *socks5.Server
-	socks5tunnel *superproxy.SuperProxy
+	socks5Proxy  *socks5.Server
+	socks5Tunnel *superproxy.SuperProxy
 	bufioPool    *bufiopool.Pool
-	tinydns      *tinydns.TinyDNS
-	rbhttp       *rbtransport.RoundTransport
-	rbsocks5     *rbtransport.RoundTransport
+	tinyDNS      *tinydns.TinyDNS
+	rbHTTP       *rbtransport.RoundTransport
+	rbSOCKS5     *rbtransport.RoundTransport
 	proxifyMux   *http.ServeMux // serve banner page and static files
 	listenAddr   string
 }
@@ -117,27 +117,27 @@ func NewProxy(options *Options) (*Proxy, error) {
 		Kafka:        options.Kafka,
 	})
 
-	var tdns *tinydns.TinyDNS
+	var tDNS *tinydns.TinyDNS
 
 	fastdialerOptions := fastdialer.DefaultOptions
 	fastdialerOptions.EnableFallback = true
 	fastdialerOptions.Deny = options.Deny
 	fastdialerOptions.Allow = options.Allow
 	if options.ListenDNSAddr != "" {
-		dnsmapping := make(map[string]*tinydns.DnsRecord)
+		dnsMapping := make(map[string]*tinydns.DnsRecord)
 		for _, record := range strings.Split(options.DNSMapping, ",") {
 			data := strings.Split(record, ":")
 			if len(data) != 2 {
 				continue
 			}
-			dnsmapping[data[0]] = &tinydns.DnsRecord{A: []string{data[1]}}
+			dnsMapping[data[0]] = &tinydns.DnsRecord{A: []string{data[1]}}
 		}
 		var err error
-		tdns, err = tinydns.New(&tinydns.Options{
+		tDNS, err = tinydns.New(&tinydns.Options{
 			ListenAddress:   options.ListenDNSAddr,
 			Net:             "udp",
 			UpstreamServers: []string{options.DNSFallbackResolver},
-			DnsRecords:      dnsmapping,
+			DnsRecords:      dnsMapping,
 		})
 		if err != nil {
 			return nil, err
@@ -149,20 +149,20 @@ func NewProxy(options *Options) (*Proxy, error) {
 		return nil, err
 	}
 
-	var rbhttp, rbsocks5 *rbtransport.RoundTransport
+	var rbHTTP, rbSOCKS5 *rbtransport.RoundTransport
 	if len(options.UpstreamHTTPProxies) > 0 {
-		rbhttp, err = rbtransport.NewWithOptions(options.UpstreamProxyRequestsNumber, options.UpstreamHTTPProxies...)
+		rbHTTP, err = rbtransport.NewWithOptions(options.UpstreamProxyRequestsNumber, options.UpstreamHTTPProxies...)
 		if err != nil {
 			return nil, err
 		}
 	}
-	if len(options.UpstreamSock5Proxies) > 0 {
-		rbsocks5, err = rbtransport.NewWithOptions(options.UpstreamProxyRequestsNumber, options.UpstreamSock5Proxies...)
+	if len(options.UpstreamSOCKS5Proxies) > 0 {
+		rbSOCKS5, err = rbtransport.NewWithOptions(options.UpstreamProxyRequestsNumber, options.UpstreamSOCKS5Proxies...)
 		if err != nil {
 			return nil, err
 		}
 	}
-	pmux, err := getProxifyServerMux()
+	pMux, err := getProxifyServerMux()
 	if err != nil {
 		return nil, err
 	}
@@ -171,31 +171,31 @@ func NewProxy(options *Options) (*Proxy, error) {
 		logger:     logger,
 		options:    options,
 		Dialer:     dialer,
-		tinydns:    tdns,
-		rbhttp:     rbhttp,
-		rbsocks5:   rbsocks5,
-		proxifyMux: pmux,
+		tinyDNS:    tDNS,
+		rbHTTP:     rbHTTP,
+		rbSOCKS5:   rbSOCKS5,
+		proxifyMux: pMux,
 	}
 
 	if err := proxy.setupHTTPProxy(); err != nil {
 		return nil, err
 	}
 
-	var socks5proxy *socks5.Server
-	if options.ListenAddrSocks5 != "" {
+	var socks5Proxy *socks5.Server
+	if options.ListenAddrSOCKS5 != "" {
 		if options.Verbosity <= types.VerbositySilent {
-			socks5proxy = socks5.NewServer(
+			socks5Proxy = socks5.NewServer(
 				socks5.WithLogger(socks5.NewLogger(log.New(io.Discard, "", log.Ltime|log.Lshortfile))),
 				socks5.WithDial(proxy.httpTunnelDialer),
 			)
 		} else {
-			socks5proxy = socks5.NewServer(
+			socks5Proxy = socks5.NewServer(
 				socks5.WithDial(proxy.httpTunnelDialer),
 			)
 		}
 	}
 
-	proxy.socks5proxy = socks5proxy
+	proxy.socks5Proxy = socks5Proxy
 
 	return proxy, nil
 }
@@ -404,11 +404,11 @@ func (p *Proxy) MatchReplaceResponse(resp *http.Response) error {
 func (p *Proxy) Run() error {
 	var wg sync.WaitGroup
 
-	if p.tinydns != nil {
+	if p.tinyDNS != nil {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			if err := p.tinydns.Run(); err != nil {
+			if err := p.tinyDNS.Run(); err != nil {
 				gologger.Warning().Msgf("Could not start dns server: %s\n", err)
 			}
 		}()
@@ -437,7 +437,7 @@ func (p *Proxy) Run() error {
 	}
 
 	// socks5 proxy
-	if p.socks5proxy != nil {
+	if p.socks5Proxy != nil {
 		if p.httpProxy != nil {
 			httpProxyIP, httpProxyPort, err := net.SplitHostPort(p.options.ListenAddrHTTP)
 			if err != nil {
@@ -447,7 +447,7 @@ func (p *Proxy) Run() error {
 			if err != nil {
 				return err
 			}
-			p.socks5tunnel, err = superproxy.NewSuperProxy(httpProxyIP, uint16(httpProxyPortUint), superproxy.ProxyTypeHTTP, "", "", "")
+			p.socks5Tunnel, err = superproxy.NewSuperProxy(httpProxyIP, uint16(httpProxyPortUint), superproxy.ProxyTypeHTTP, "", "", "")
 			if err != nil {
 				return err
 			}
@@ -458,7 +458,7 @@ func (p *Proxy) Run() error {
 		go func() {
 			defer wg.Done()
 
-			gologger.Fatal().Msgf("%v", p.socks5proxy.ListenAndServe("tcp", p.options.ListenAddrSocks5))
+			gologger.Fatal().Msgf("%v", p.socks5Proxy.ListenAndServe("tcp", p.options.ListenAddrSOCKS5))
 		}()
 	}
 
@@ -504,21 +504,21 @@ func (p *Proxy) getRoundTripper() (http.RoundTripper, error) {
 
 	if len(p.options.UpstreamHTTPProxies) > 0 {
 		roundtrip = &http.Transport{Proxy: func(req *http.Request) (*url.URL, error) {
-			return url.Parse(p.rbhttp.Next())
+			return url.Parse(p.rbHTTP.Next())
 		}, TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}
-	} else if len(p.options.UpstreamSock5Proxies) > 0 {
+	} else if len(p.options.UpstreamSOCKS5Proxies) > 0 {
 		// for each socks5 proxy create a dialer
 		socks5Dialers := make(map[string]proxy.Dialer)
-		for _, socks5proxy := range p.options.UpstreamSock5Proxies {
-			dialer, err := proxy.SOCKS5("tcp", socks5proxy, nil, proxy.Direct)
+		for _, socks5Proxy := range p.options.UpstreamSOCKS5Proxies {
+			dialer, err := proxy.SOCKS5("tcp", socks5Proxy, nil, proxy.Direct)
 			if err != nil {
 				return nil, err
 			}
-			socks5Dialers[socks5proxy] = dialer
+			socks5Dialers[socks5Proxy] = dialer
 		}
 		roundtrip = &http.Transport{Dial: func(network, addr string) (net.Conn, error) {
 			// lookup next dialer
-			socks5Proxy := p.rbsocks5.Next()
+			socks5Proxy := p.rbSOCKS5.Next()
 			socks5Dialer := socks5Dialers[socks5Proxy]
 			// use it to perform the request
 			return socks5Dialer.Dial(network, addr)
@@ -528,7 +528,7 @@ func (p *Proxy) getRoundTripper() (http.RoundTripper, error) {
 }
 
 func (p *Proxy) httpTunnelDialer(ctx context.Context, network, addr string) (net.Conn, error) {
-	return p.socks5tunnel.MakeTunnel(nil, nil, p.bufioPool, addr)
+	return p.socks5Tunnel.MakeTunnel(nil, nil, p.bufioPool, addr)
 }
 
 func (p *Proxy) hijackNServe(req *http.Request, ctx *martian.Context) error {

static/index.html

@@ -162,7 +162,7 @@
         <div class="center-text">
             Swiss Army Knife Proxy for rapid deployments. <br>
             Supports multiple operations such as request/response dump,<br>
-            filtering and manipulation via DSL language, upstream HTTP/Socks5 proxy.<br>
+            filtering and manipulation via DSL language, upstream HTTP/SOCKS5 proxy.<br>
             Additionally, a replay utility allows to import the dumped traffic <br>
             (request/responses with correct domain name) into BurpSuite or <br>
             any other proxy by simply setting the upstream proxy to proxify.