-
Notifications
You must be signed in to change notification settings - Fork 0
/
gscan.go
206 lines (167 loc) · 4.21 KB
/
gscan.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
package main
import (
"flag"
"fmt"
"gscan/config"
"net"
"sort"
"time"
)
const Version = "v0.9.3a"
type Bar struct {
percent uint8
current int
total int
rate string
graph string
// pgchan chan int
}
func (b *Bar) getPercent() uint8 {
return uint8(float32(b.current) / float32(b.total) * 100)
}
func (b *Bar) setRate(incret int) {
switch incret {
case 0:
case 1:
b.rate += b.graph
b.percent = b.getPercent()
default:
for i := 0; i < incret; i++ {
b.rate += b.graph
}
b.percent = b.getPercent()
}
}
func (b *Bar) Play(cur chan int) {
for b.current = range cur {
b.setRate(int(b.getPercent() - b.percent))
fmt.Printf("\r\x1b[01;40;36m>[%c][%-100s]%3d%% \x1b[0m%8d/%d\x1b[K\r", 'x', b.rate, b.percent, b.current, b.total)
//jdt[b.current%len(jdt)]
}
}
func portInfo(ptl string) {
// This function is Copy from another file, still in the Development Stage
var args string
var ports []int
var dfps = []int{23, 25, 53, 88, 139, 389, 443, 445, 3389, 5432}
// default show some port info
if len(ptl) > 1 {
// plt -> os.Args can be a single go.file
// args = strings.Join(ptl[1:], "")
args = ptl
ports = config.PortListProc(args)
} else {
ports = dfps
}
infos := config.NmapServices
fmt.Println("")
for _, port := range ports {
fmt.Printf("%d: %s\n", port, infos[port])
}
}
func Play(cur chan int, v int) {
//
// With Channel Optimization, there is no longer a need for prior InitBar first to improve performance
var DefaultBar Bar
DefaultBar.graph = "#"
DefaultBar.total = v
DefaultBar.current = 0
DefaultBar.setRate(0)
go DefaultBar.Play(cur)
}
func portScan(host string, timeout int, thread int) (openports []int, opennum int) {
// The default recommended Thread is 700
// The default recommended Timeout is 60
ports := make(chan int, thread)
results := make(chan int)
defer close(ports)
defer close(results)
for i := 1; i < cap(ports); i++ {
go worker(host, timeout, ports, results)
}
go func() {
curnum := make(chan int)
Play(curnum, 65535)
for i := range 65535 {
ports <- i + 1
if i%6 == 0 {
curnum <- i
}
}
}()
for range 65535 {
port := <-results
if port != 0 {
openports = append(openports, port)
}
}
sort.Ints(openports)
opennum = len(openports)
return
}
func worker(host string, adjusttimeout int, ports chan int, results chan int) {
for p := range ports {
address := fmt.Sprintf("%s:%d", host, p)
conn, err := net.DialTimeout("tcp", address, time.Duration(adjusttimeout)*time.Millisecond)
if err != nil {
results <- 0
continue
}
defer conn.Close()
results <- p
}
}
func Banner(start time.Time) {
var banner string
banner = "Starting Gscan " + Version + "(github.com/Gr-1m/gscan)"
fmt.Printf("%s at %v\n", banner, start.Format("2006-01-02 15:04 MST"))
return
}
func main() {
start := time.Now()
Banner(start)
var (
openports []int
timeout int
threads int
)
flag.IntVar(&timeout, "to", 60, "Config TCP wait Timeout")
flag.IntVar(&threads, "th", 650, "Config Max Thread you want")
target := flag.String("ip", "", "The Target Host IPaddress for Scan")
max_portnum := flag.Int("n", 20, "Config Output nmapCommand max port number")
pinfo := flag.String("pi", "", "Still in the Development Stage")
flag.Parse()
if *pinfo != "" {
fmt.Println("The Port INFO you want is as follows : ")
portInfo(*pinfo)
if *target == "" {
return
}
}
if *target == "" {
flag.Usage()
return
} else {
var waittime = 65536 * (float64(timeout) + 1.581) / float64(threads)
fmt.Printf("\n[!] Please wait for about %.3fs\n\r", waittime/1000)
}
openports, opennum := portScan(*target, timeout, threads)
fmt.Println("\nresults: ")
for _, port := range openports {
fmt.Printf("%d is open\n", port)
}
fmt.Printf("[*] Gscan Finish, scanned in: %.3f\n", time.Since(start).Seconds())
// nmap command output
if opennum == 0 {
fmt.Println("Detect No Port Open")
}
if opennum < *max_portnum {
fmt.Printf("You can use: \n\t nmap %s -p", *target)
for _, port := range openports {
fmt.Printf("%d,", port)
}
fmt.Println("\b \n\nTo Check services running on these ports")
} else {
fmt.Printf("Open ports is too many(%d), if you want use nmap You can add the -n to config maxOutputPortNum", opennum)
}
}