STRLCPY/metabigor

■ ■ ■ ■ ■ ■

cmd/cve.go

■ ■ ■ ■ ■ ■

cmd/net.go

		skipped 171 lines
172	172
173	173		// StoreData store data to output
174	174		func StoreData(data []string, options core.Options) {
175		-	if len(data) > 0 {
176		-	fmt.Println(strings.Join(data, "\n"))
177		-	_, err := core.AppendToContent(options.Output, strings.Join(data, "\n"))
178		-	if err == nil {
179		-	core.InforF("Write output to: %v", options.Output)
180		-	}
	175	+	if len(data) == 0 {
	176	+	core.ErrorF("Empty data to write")
	177	+	return
	178	+	}
	179	+
	180	+	fmt.Println(strings.Join(data, "\n"))
	181	+	_, err := core.AppendToContent(options.Output, strings.Join(data, "\n"))
	182	+	if err == nil {
	183	+	core.InforF("Write output to: %v", options.Output)
181	184		}
182	185		}
183	186

■ ■ ■ ■ ■ ■

cmd/scan.go

		skipped 118 lines
119	119		} else {
120	120		result = modules.RunMasscan(options.Scan.InputFile, options)
121	121		}
	122	+	StoreData(result, options)
122	123		return nil
123	124
124	125		}
		skipped 112 lines
237	238		for _, file := range Files {
238	239		filename := file.Name()
239	240		core.DebugF("Reading: %v", filename)
240		-	if strings.HasSuffix(file.Name(), "xml") && strings.HasPrefix(filename, "masscan") {
	241	+	if strings.HasPrefix(filename, "masscan") {
241	242		data := core.GetFileContent(filename)
242	243		fmt.Println(data)
243	244		rawResult := modules.ParsingMasscan(data)
		skipped 10 lines
254	255		// StoreTmpInput store list of string to tmp file
255	256		func StoreTmpInput(raw []string, options core.Options) string {
256	257		tmpDest := options.Scan.TmpOutput
257		-	tmpFile, _ := ioutil.TempFile(options.Scan.TmpOutput, "zmap-*.txt")
	258	+	tmpFile, _ := ioutil.TempFile(options.Scan.TmpOutput, "joined-*.txt")
258	259		if tmpDest != "" {
259		-	tmpFile, _ = ioutil.TempFile(tmpDest, "zmap-input-*.txt")
	260	+	tmpFile, _ = ioutil.TempFile(tmpDest, "joined-input-*.txt")
260	261		}
261	262		tmpDest = tmpFile.Name()
262	263		core.WriteToFile(tmpDest, strings.Join(raw, "\n"))
		skipped 18 lines

■ ■ ■ ■ ■ ■

core/common.go

		skipped 81 lines
82	82
83	83		// ErrorF print good message
84	84		func ErrorF(format string, args ...interface{}) {
85		-	good := color.RedString("ERROR")
86		-	fmt.Fprintf(os.Stderr, "%s %s\n", good, fmt.Sprintf(format, args...))
	85	+	logger.Error(fmt.Sprintf(format, args...))
87	86		}
88	87

■ ■ ■ ■ ■ ■

core/filter.go

		skipped 14 lines
15	15		return result
16	16		}
17	17
18		-
19	18		// FilterIpv6 only get Ipv6
20	19		func FilterIpv6(raw []string) []string {
21	20		var result []string
		skipped 7 lines
29	28		return result
30	29		}
31	30
32		-

■ ■ ■ ■ ■ ■

core/options.go

		skipped 18 lines
19	19		Scan ScanOptions
20	20		Net NetOptions
21	21		Search SearchOptions
22		-	CVE CVEOptions
	22	+	CVE CVEOptions
23	23		}
24	24
25	25		// ScanOptions options for net command
		skipped 19 lines
45	45		type NetOptions struct {
46	46		Asn string
47	47		Org string
48		-	IP string
49		-	Domain string
	48	+	IP string
	49	+	Domain string
50	50		Optimize bool
51	51		}
52	52
		skipped 5 lines
58	58		More bool
59	59		}
60	60
61		-
62	61		// CVEOptions options for cve command
63	62		type CVEOptions struct {
64		-	Software string
65		-	Version string
	63	+	Software string
	64	+	Version string
66	65		}
67	66
68	67		// Request all information about request
		skipped 29 lines

■ ■ ■ ■ ■ ■

modules/cve.go

		skipped 16 lines
17	17		*/
18	18
19	19		type CVEData struct {
20		-	CVE string
21		-	Title string
22		-	Desc string
23		-	Raw string
24		-	RawQuery string
	20	+	CVE string
	21	+	Title string
	22	+	Desc string
	23	+	Raw string
	24	+	RawQuery string
25	25		}
26	26
27	27		// Vulners get Org CIDR from asnlookup
		skipped 66 lines

■ ■ ■ ■ ■ ■

modules/netblock_test.go

		skipped 59 lines
60	60		}
61	61		}
62	62
63		-
64	63		func TestASNFromIP(t *testing.T) {
65	64		var options core.Options
66	65		options.Net.IP = "168.120.1.1"
		skipped 3 lines
70	69		}
71	70		}
72	71
73		-

■ ■ ■ ■ ■ ■

modules/scan.go

		skipped 44 lines
45	45		var realResult []string
46	46		result := make(map[string]string)
47	47		if !core.FileExists(massOutput) {
	48	+	core.ErrorF("Output not found: %v", massOutput)
48	49		return realResult
49	50		}
	51	+	core.InforF("Parsing result from: %v", massOutput)
50	52		data := core.GetFileContent(massOutput)
51	53		rawResult := ParsingMasscan(data)
	54	+
	55	+	if len(rawResult) == 0 {
	56	+	core.ErrorF("Output not found: %v", massOutput)
	57	+	}
	58	+
52	59		// get flat output for easily parse to other tools
53	60		if options.Scan.Flat {
54	61		for k, v := range rawResult {
55	62		for _, port := range v {
56		-	realResult = append(realResult, fmt.Sprintf("%v:%v", k, port))
	63	+	info := fmt.Sprintf("%v:%v", k, port)
	64	+	realResult = append(realResult, info)
57	65		}
58	66		}
59	67		return realResult
60	68		}
61	69
62		-	// group them by host
	70	+	// group them by host in verbose mode
63	71		for k, v := range rawResult {
64	72		result[k] += fmt.Sprintf("%v", strings.Join(v, ","))
65	73		}
66		-
67	74		for k, v := range result {
68	75		realResult = append(realResult, fmt.Sprintf("%v - %v", k, v))
69	76		}
70	77
71	78		return realResult
72		-	}
73		-
74		-	type nmap struct {
75	79		}
76	80
77	81		// RunNmap run nmap command and return list of port open
		skipped 84 lines
162	166		func ParsingMasscan(raw string) map[string][]string {
163	167		result := make(map[string][]string)
164	168		data := strings.Split(raw, "\n")
	169	+	if len(data) == 0 {
	170	+	core.ErrorF("Invalid Masscan data")
	171	+	return result
	172	+	}
165	173
166	174		for _, line := range data {
167	175		if !strings.Contains(line, "Host: ") {
		skipped 63 lines

■ ■ ■ ■ ■ ■

modules/scan_test.go

		skipped 27 lines
28	28		}
29	29
30	30		func TestParseMassScan(t *testing.T) {
31		-	raw := core.GetFileContent("/tmp/ddemo")
	31	+	raw := core.GetFileContent("/tmp/mtt/mrp")
32	32		result := ParsingMasscan(raw)
33	33		fmt.Println(result)
34	34		if len(result) == 0 {
		skipped 12 lines