cmd.NewScanCommand - Code Metrics - Inspection of "Refactoring target creation and result handling in..." - stefanoj3/dirstalk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#52)

by Stefano

created 2019-07-09 15:14 UTC

cmd.NewScanCommand B

↳ Parent: pkg/cmd/scan.go

Complexity

Conditions

Size

Total Lines	85
Code Lines	60

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	60
nop	1
dl	0
loc	85
rs	8.309
c	0
b	0
f	0

How to fix Long Method

package cmd

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

	"github.com/pkg/errors"
	"github.com/sirupsen/logrus"
	"github.com/spf13/cobra"
	"github.com/stefanoj3/dirstalk/pkg/dictionary"
	"github.com/stefanoj3/dirstalk/pkg/scan"
	"github.com/stefanoj3/dirstalk/pkg/scan/client"
	"github.com/stefanoj3/dirstalk/pkg/scan/producer"
)

func NewScanCommand(logger *logrus.Logger) (*cobra.Command, error) {

	cmd := &cobra.Command{
		Use:   "scan [url]",
		Short: "Scan the given URL",
		RunE:  buildScanFunction(logger),
	}

	cmd.Flags().StringP(
		flagDictionary,
		flagDictionaryShort,
		"",
		"dictionary to use for the scan (path to local file or remote url)",
	)
	err := cmd.MarkFlagFilename(flagDictionary)
	if err != nil {
		return nil, err
	}

	err = cmd.MarkFlagRequired(flagDictionary)
	if err != nil {
		return nil, err
	}

	cmd.Flags().StringSlice(
		flagHTTPMethods,
		[]string{"GET"},
		"comma separated list of http methods to use; eg: GET,POST,PUT",
	)

	cmd.Flags().IntP(
		flagThreads,
		flagThreadsShort,
		3,
		"amount of threads for concurrent requests",
	)

	cmd.Flags().IntP(
		flagHTTPTimeout,
		"",
		5000,
		"timeout in milliseconds",
	)

	cmd.Flags().IntP(
		flagScanDepth,
		"",
		3,
		"scan depth",
	)

	cmd.Flags().StringP(
		flagSocks5Host,
		"",
		"",
		"socks5 host to use",
	)

	cmd.Flags().StringP(
		flagUserAgent,
		"",
		"",
		"user agent to use for http requests",
	)

	cmd.Flags().BoolP(
		flagCookieJar,
		"",
		false,
		"enables the use of a cookie jar: it will retain any cookie sent "+
			"from the server and send them for the following requests",
	)

	cmd.Flags().StringArray(
		flagCookie,
		[]string{},
		"cookie to add to each request; eg name=value (can be specified multiple times)",
	)

	cmd.Flags().StringArray(
		flagHeader,
		[]string{},
		"header to add to each request; eg name=value (can be specified multiple times)",
	)

	return cmd, nil
}

func buildScanFunction(logger *logrus.Logger) func(cmd *cobra.Command, args []string) error {
	f := func(cmd *cobra.Command, args []string) error {
		u, err := getURL(args)
		if err != nil {
			return err
		}

		cnf, err := scanConfigFromCmd(cmd)
		if err != nil {
			return errors.Wrap(err, "failed to build config")
		}

		return StartScan(logger, cnf, u)
	}

	return f
}

func getURL(args []string) (*url.URL, error) {
	if len(args) == 0 {
		return nil, errors.New("no URL provided")
	}

	arg := args[0]

	u, err := url.ParseRequestURI(arg)
	if err != nil {
		return nil, errors.Wrap(err, "the first argument must be a valid url")
	}

	return u, nil
}

// StartScan is a convenience method that wires together all the dependencies needed to start a scan
func StartScan(logger *logrus.Logger, cnf *scan.Config, u *url.URL) error {
	c, err := client.NewClientFromConfig(
		cnf.TimeoutInMilliseconds,
		cnf.Socks5Url,
		cnf.UserAgent,
		cnf.UseCookieJar,
		cnf.Cookies,
		cnf.Headers,
		u,
	)
	if err != nil {
		return errors.Wrap(err, "failed to build client")
	}

	dict, err := dictionary.NewDictionaryFrom(cnf.DictionaryPath, c)
	if err != nil {
		return errors.Wrap(err, "failed to build dictionary")
	}

	targetProducer := producer.NewDictionaryProducer(cnf.HTTPMethods, dict, cnf.ScanDepth)
	decoratedProducer := producer.NewReProducer(
		cnf.HTTPMethods,
		dict,
		targetProducer,
		time.Millisecond*(time.Duration(cnf.TimeoutInMilliseconds)+50),
	)

	s := scan.NewScanner(
		c,
		decoratedProducer,
		logger,
	)

	logger.WithFields(logrus.Fields{
		"url":               u.String(),
		"threads":           cnf.Threads,
		"dictionary-length": len(dict),
		"scan-depth":        cnf.ScanDepth,
		"timeout":           cnf.TimeoutInMilliseconds,
		"socks5":            cnf.Socks5Url,
		"cookies":           strigifyCookies(cnf.Cookies),
		"cookie-jar":        cnf.UseCookieJar,
		"headers":           stringyfyHeaders(cnf.Headers),
		"user-agent":        cnf.UserAgent,
	}).Info("Starting scan")

	resultLogger := scan.NewResultLogger(logger)
	summarizer := scan.NewResultSummarizer(logger.Out)
	for result := range s.Scan(u, cnf.Threads) {
		decoratedProducer.Reproduce(result)
		resultLogger.Log(result)
		summarizer.Add(result)
	}

	summarizer.Summarize()

	logger.Info("Finished scan")

	return nil
}

func strigifyCookies(cookies []*http.Cookie) string {
	result := ""

	for _, cookie := range cookies {
		result += fmt.Sprintf("{%s=%s}", cookie.Name, cookie.Value)
	}

	return result
}

func stringyfyHeaders(headers map[string]string) string {
	result := ""

	for name, value := range headers {
		result += fmt.Sprintf("{%s:%s}", name, value)
	}

	return result
}


1			package cmd
2
3			import (
4			"fmt"
5			"net/http"
6			"net/url"
7			"time"
8
9			"github.com/pkg/errors"
10			"github.com/sirupsen/logrus"
11			"github.com/spf13/cobra"
12			"github.com/stefanoj3/dirstalk/pkg/dictionary"
13			"github.com/stefanoj3/dirstalk/pkg/scan"
14			"github.com/stefanoj3/dirstalk/pkg/scan/client"
15			"github.com/stefanoj3/dirstalk/pkg/scan/producer"
16			)
17
18			func NewScanCommand(logger logrus.Logger) (cobra.Command, error) {
			0 ignored issues – show introduced 2019-05-12 05:00 UTC by Report Bug Copy Issue Report exported function NewScanCommand should have comment or be unexported Loading history...
19			cmd := &cobra.Command{
20			Use: "scan [url]",
21			Short: "Scan the given URL",
22			RunE: buildScanFunction(logger),
23			}
24
25			cmd.Flags().StringP(
26			flagDictionary,
27			flagDictionaryShort,
28			"",
29			"dictionary to use for the scan (path to local file or remote url)",
30			)
31			err := cmd.MarkFlagFilename(flagDictionary)
32			if err != nil {
33			return nil, err
34			}
35
36			err = cmd.MarkFlagRequired(flagDictionary)
37			if err != nil {
38			return nil, err
39			}
40
41			cmd.Flags().StringSlice(
42			flagHTTPMethods,
43			[]string{"GET"},
44			"comma separated list of http methods to use; eg: GET,POST,PUT",
45			)
46
47			cmd.Flags().IntP(
48			flagThreads,
49			flagThreadsShort,
50			3,
51			"amount of threads for concurrent requests",
52			)
53
54			cmd.Flags().IntP(
55			flagHTTPTimeout,
56			"",
57			5000,
58			"timeout in milliseconds",
59			)
60
61			cmd.Flags().IntP(
62			flagScanDepth,
63			"",
64			3,
65			"scan depth",
66			)
67
68			cmd.Flags().StringP(
69			flagSocks5Host,
70			"",
71			"",
72			"socks5 host to use",
73			)
74
75			cmd.Flags().StringP(
76			flagUserAgent,
77			"",
78			"",
79			"user agent to use for http requests",
80			)
81
82			cmd.Flags().BoolP(
83			flagCookieJar,
84			"",
85			false,
86			"enables the use of a cookie jar: it will retain any cookie sent "+
87			"from the server and send them for the following requests",
88			)
89
90			cmd.Flags().StringArray(
91			flagCookie,
92			[]string{},
93			"cookie to add to each request; eg name=value (can be specified multiple times)",
94			)
95
96			cmd.Flags().StringArray(
97			flagHeader,
98			[]string{},
99			"header to add to each request; eg name=value (can be specified multiple times)",
100			)
101
102			return cmd, nil
103			}
104
105			func buildScanFunction(logger logrus.Logger) func(cmd cobra.Command, args []string) error {
106			f := func(cmd *cobra.Command, args []string) error {
107			u, err := getURL(args)
108			if err != nil {
109			return err
110			}
111
112			cnf, err := scanConfigFromCmd(cmd)
113			if err != nil {
114			return errors.Wrap(err, "failed to build config")
115			}
116
117			return StartScan(logger, cnf, u)
118			}
119
120			return f
121			}
122
123			func getURL(args []string) (*url.URL, error) {
124			if len(args) == 0 {
125			return nil, errors.New("no URL provided")
126			}
127
128			arg := args[0]
129
130			u, err := url.ParseRequestURI(arg)
131			if err != nil {
132			return nil, errors.Wrap(err, "the first argument must be a valid url")
133			}
134
135			return u, nil
136			}
137
138			// StartScan is a convenience method that wires together all the dependencies needed to start a scan
139			func StartScan(logger logrus.Logger, cnf scan.Config, u *url.URL) error {
140			c, err := client.NewClientFromConfig(
141			cnf.TimeoutInMilliseconds,
142			cnf.Socks5Url,
143			cnf.UserAgent,
144			cnf.UseCookieJar,
145			cnf.Cookies,
146			cnf.Headers,
147			u,
148			)
149			if err != nil {
150			return errors.Wrap(err, "failed to build client")
151			}
152
153			dict, err := dictionary.NewDictionaryFrom(cnf.DictionaryPath, c)
154			if err != nil {
155			return errors.Wrap(err, "failed to build dictionary")
156			}
157
158			targetProducer := producer.NewDictionaryProducer(cnf.HTTPMethods, dict, cnf.ScanDepth)
159			decoratedProducer := producer.NewReProducer(
160			cnf.HTTPMethods,
161			dict,
162			targetProducer,
163			time.Millisecond*(time.Duration(cnf.TimeoutInMilliseconds)+50),
164			)
165
166			s := scan.NewScanner(
167			c,
168			decoratedProducer,
169			logger,
170			)
171
172			logger.WithFields(logrus.Fields{
173			"url": u.String(),
174			"threads": cnf.Threads,
175			"dictionary-length": len(dict),
176			"scan-depth": cnf.ScanDepth,
177			"timeout": cnf.TimeoutInMilliseconds,
178			"socks5": cnf.Socks5Url,
179			"cookies": strigifyCookies(cnf.Cookies),
180			"cookie-jar": cnf.UseCookieJar,
181			"headers": stringyfyHeaders(cnf.Headers),
182			"user-agent": cnf.UserAgent,
183			}).Info("Starting scan")
184
185			resultLogger := scan.NewResultLogger(logger)
186			summarizer := scan.NewResultSummarizer(logger.Out)
187			for result := range s.Scan(u, cnf.Threads) {
188			decoratedProducer.Reproduce(result)
189			resultLogger.Log(result)
190			summarizer.Add(result)
191			}
192
193			summarizer.Summarize()
194
195			logger.Info("Finished scan")
196
197			return nil
198			}
199
200			func strigifyCookies(cookies []*http.Cookie) string {
201			result := ""
202
203			for _, cookie := range cookies {
204			result += fmt.Sprintf("{%s=%s}", cookie.Name, cookie.Value)
205			}
206
207			return result
208			}
209
210			func stringyfyHeaders(headers map[string]string) string {
211			result := ""
212
213			for name, value := range headers {
214			result += fmt.Sprintf("{%s:%s}", name, value)
215			}
216
217			return result
218			}
219

stefanoj3 / dirstalk

Pull Request — master (#52)

cmd.NewScanCommand B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like