go语言制作端口扫描器

本文给大家分享的是使用go语言编写的TCP端口扫描器，可以选择IP范围，扫描的端口，以及多线程，有需要的小伙伴可以参考下。

GO语言编写的TCP端口扫描器，本人的第一个GO程序。

Git@OSC：http://git.oschina.net/youshusoft/GoScanner

使用命令：

Scanner startIp [endIp] port thread

参数说明：

startIp 开始IP

endIp 结束IP,可选,不输入表示只扫描startIp

port 扫描端口,单个端口：3389;多个端口：1433,3389;连续端口：135-3389

thread 最大并发线程数,最高2048

扫描结果保存在同目录下的 result.txt 中，每次启动都会清掉之前的内容。

例子一:

Scanner 58.96.172.22 58.96.172.220 80 512

扫描58.96.172.22到58.96.172.220中的80端口，最大并发线程512。

例子二：

Scanner 58.96.172.22 58.96.172.220 21,5631 512

扫描58.96.172.22到58.96.172.220中的21和5631端口，最大并发线程512。

例子三：

Scanner 58.96.172.22 58.96.172.220 1-520 512

扫描58.96.172.22到58.96.172.220中的1到520端口，最大并发线程512。

例子四：

Scanner 58.96.172.22 1-520 512

扫描58.96.172.22中的1到520端口，最大并发线程512。

1. package main 
2. import ( 
3. "fmt" 
4. "strconv" 
5. "flag" 
6. "strings" 
7. "net" 
8. "os" 
9. ) 
10. /** 
11. 扫描地址 
12. */ 
13. var ipAddrs chan string = make(chan string) 
14. //扫描结果 
15. var result chan string = make(chan string) 
16. //线程数 
17. var thread chan int = make(chan int) 
18. var nowThread int; 
19. //关闭程序 
20. var clo chan bool = make(chan bool) 
21. //保存结果 
22. func writeResult(){ 
23. fileName := "result.txt" 
24. fout,err := os.Create(fileName) 
25. if err != nil{ 
26. //文件创建失败 
27. fmt.Println(fileName + " create error") 
28. } 
29. defer fout.Close() 
30. s,ok := <- result 
31. for ;ok;{ 
32. fout.WriteString(s + "/r/n") 
33. s,ok = <- result 
34. } 
35. //通知进程退出 
36. clo <- true;  
37. } 
38. //根据线程参数启动扫描线程 
39. func runScan(){ 
40. t,ok := <- thread 
41. nowThread = t; 
42. if ok{ 
43. for i := 0;i < nowThread;i++{ 
44. go scan(strconv.Itoa(i)) 
45. } 
46. } 
47. //等待线程终止 
48. for;<-thread == 0;{ 
49. nowThread-- 
50. if nowThread == 0{ 
51. //全部线程已终止,关闭结果写入,退出程序 
52. close(result) 
53. break 
54. } 
55. } 
56. } 
57. /** 
58. 扫描线程 
59. */ 
60. func scan(threadId string){ 
61. s,ok := <-ipAddrs 
62. for;ok;{ 
63. fmt.Println("[thread-" + threadId + "] scan:" + s) 
64. _,err := net.Dial("tcp",s) 
65. if err == nil{ 
66. //端口开放 
67. result <- s  
68. } 
69. s,ok = <-ipAddrs 
70. } 
71. fmt.Println("[thread-" + threadId + "] end") 
72. thread <- 0; 
73. } 
74. //获取下一个IP 
75. func nextIp(ip string) string{ 
76. ips := strings.Split(ip,".") 
77. var i int; 
78. for i = len(ips) - 1;i >= 0;i--{ 
79. n,_ := strconv.Atoi(ips[i]) 
80. if n >= 255{ 
81. //进位 
82. ips[i] = "1" 
83. }else{ 
84. //+1 
85. n++ 
86. ips[i] = strconv.Itoa(n) 
87. break 
88. } 
89. } 
90. if i == -1{ 
91. //全部IP段都进行了进位,说明此IP本身已超出范围 
92. return ""; 
93. } 
94. ip = "" 
95. leng := len(ips) 
96. for i := 0;i < leng;i++{ 
97. if i == leng -1{ 
98. ip += ips[i] 
99. }else{ 
100. ip += ips[i] + "." 
101. } 
102. } 
103. return ip 
104. } 
105. //生成IP地址列表 
106. func processIp(startIp,endIp string) []string{ 
107. var ips = make([]string,0) 
108. for ;startIp != endIp;startIp = nextIp(startIp){ 
109. if startIp != ""{ 
110. ips = append(ips,startIp) 
111. } 
112. } 
113. ips = append(ips,startIp) 
114. return ips 
115. } 
116. //处理参数 
117. func processFlag(arg []string){ 
118. //开始IP,结束IP 
119. var startIp,endIp string 
120. //端口 
121. var ports []int = make([]int,0) 
122. index := 0 
123. startIp = arg[index] 
124. si := net.ParseIP(startIp) 
125. if si == nil{ 
126. //开始IP不合法 
127. fmt.Println("'startIp' Setting error") 
128. return 
129. } 
130. index++ 
131. endIp = arg[index] 
132. ei := net.ParseIP(endIp) 
133. if(ei == nil){ 
134. //未指定结束IP,即只扫描一个IP 
135. endIp = startIp 
136. }else{ 
137. index++ 
138. } 
139. tmpPort := arg[index] 
140. if strings.Index(tmpPort,"-") != -1{ 
141. //连续端口 
142. tmpPorts := strings.Split(tmpPort,"-") 
143. var startPort,endPort int 
144. var err error 
145. startPort,err = strconv.Atoi(tmpPorts[0]) 
146. if err != nil || startPort < 1 || startPort > 65535{ 
147. //开始端口不合法 
148. return 
149. } 
150. if len(tmpPorts) >= 2{ 
151. //指定结束端口 
152. endPort,err = strconv.Atoi(tmpPorts[1]) 
153. if err != nil || endPort < 1 || endPort > 65535 || endPort < startPort{ 
154. //结束端口不合法 
155. fmt.Println("'endPort' Setting error") 
156. return 
157. } 
158. }else{ 
159. //未指定结束端口 
160. endPort = 65535 
161. } 
162. for i := 0;startPort + i <= endPort;i++{ 
163. ports = append(ports,startPort + i) 
164. } 
165. }else{ 
166. //一个或多个端口 
167. ps := strings.Split(tmpPort,",") 
168. for i := 0;i < len(ps);i++{ 
169. p,err := strconv.Atoi(ps[i]) 
170. if err != nil{ 
171. //端口不合法 
172. fmt.Println("'port' Setting error") 
173. return 
174. } 
175. ports = append(ports,p) 
176. } 
177. } 
178. index++ 
179. t,err := strconv.Atoi(arg[index]) 
180. if(err != nil){ 
181. //线程不合法 
182. fmt.Println("'thread' Setting error") 
183. return 
184. } 
185. //最大线程2048 
186. if t < 1{ 
187. t = 1; 
188. }else if t > 2048{ 
189. t = 2048; 
190. } 
191. //传送启动线程数 
192. thread <- t 
193. //生成扫描地址列表 
194. ips := processIp(startIp,endIp) 
195. il := len(ips) 
196. for i := 0; i < il;i++{ 
197. pl := len(ports) 
198. for j := 0;j < pl;j++{ 
199. ipAddrs <- ips[i] + ":" + strconv.Itoa(ports[j])  
200. } 
201. } 
202. close(ipAddrs) 
203. } 
204. func main(){ 
205. flag.Parse() 
206. if flag.NArg() != 3 && flag.NArg() != 4{ 
207. //参数不合法 
208. fmt.Println("Parameter error") 
209. return 
210. } 
211. //获取参数 
212. args := make([]string,0,4) 
213. for i := 0;i < flag.NArg();i++{ 
214. args = append(args,flag.Arg(i)) 
215. } 
216. //启动扫描线程 
217. go runScan() 
218. //启动结果写入线程 
219. go writeResult() 
220. //参数处理 
221. processFlag(args) 
222. //等待退出指令 
223. <- clo; 
224. fmt.Println("Exit") 
225. } 

以上所述就是本文的全部内容了，希望大家能够喜欢。