利用golang的并发优势快速扫描端口

Scanner startIp [endIp] port thread

package main

import (
"flag"
"fmt"
"net"
"os"
"strconv"
"strings"
) /**
扫描地址
*/
var ipAddrs chan string = make(chan string) //扫描结果
var result chan string = make(chan string) //线程数
var thread chan int = make(chan int)
var nowThread int //关闭程序
var clo chan bool = make(chan bool) //保存结果
func writeResult() {
fileName := "result.txt"
fout, err := os.Create(fileName)
if err != nil {
//文件创建失败
fmt.Println(fileName + " create error")
}
defer fout.Close()
s, ok := <-result
for ok {
fout.WriteString(s + "\r\n")
s, ok = <-result
}
//通知进程退出
clo <- true
} //根据线程参数启动扫描线程
func runScan() {
t, ok := <-thread
nowThread = t
if ok {
for i := 0; i < nowThread; i++ {
go scan(strconv.Itoa(i))
}
}
//等待线程终止
for <-thread == 0 {
nowThread--
if nowThread == 0 {
//全部线程已终止,关闭结果写入,退出程序
close(result)
break
}
}
} /**
扫描线程
*/
func scan(threadId string) {
s, ok := <-ipAddrs //循环从通道中拿地址
for ok {
fmt.Println("[thread-" + threadId + "] scan:" + s)
_, err := net.Dial("tcp", s)
if err == nil {
//端口开放
result <- s
}
s, ok = <-ipAddrs //循环从通道中拿地址
}
fmt.Println("[thread-" + threadId + "] end")
thread <- 0
} //获取下一个IP
func nextIp(ip string) string {
ips := strings.Split(ip, ".")
var i int
for i = len(ips) - 1; i >= 0; i-- {
n, _ := strconv.Atoi(ips[i])
if n >= 255 {
//进位
ips[i] = "1"
} else {
//+1
n++
ips[i] = strconv.Itoa(n)
break
}
} if i == -1 {
//全部IP段都进行了进位,说明此IP本身已超出范围
return ""
} ip = ""
leng := len(ips)
for i := 0; i < leng; i++ {
if i == leng-1 {
ip += ips[i]
} else {
ip += ips[i] + "."
}
}
return ip
} //生成IP地址列表
func processIp(startIp, endIp string) []string {
var ips = make([]string, 0)
for ; startIp != endIp; startIp = nextIp(startIp) {
if startIp != "" {
ips = append(ips, startIp)
}
}
ips = append(ips, startIp)
return ips
} //处理参数
func processFlag(arg []string) {
//开始IP,结束IP
var startIp, endIp string
//端口
var ports []int = make([]int, 0)
index := 0
startIp = arg[index]
si := net.ParseIP(startIp)
if si == nil {
//开始IP不合法
fmt.Println("'startIp' Setting error")
return
}
index++
endIp = arg[index]
ei := net.ParseIP(endIp)
if ei == nil {
//未指定结束IP,即只扫描一个IP
endIp = startIp
} else {
index++
} tmpPort := arg[index]
if strings.Index(tmpPort, "-") != -1 {
//连续端口
tmpPorts := strings.Split(tmpPort, "-")
var startPort, endPort int
var err error
startPort, err = strconv.Atoi(tmpPorts[0])
if err != nil || startPort < 1 || startPort > 65535 {
//开始端口不合法
return
} if len(tmpPorts) >= 2 {
//指定结束端口
endPort, err = strconv.Atoi(tmpPorts[1])
if err != nil || endPort < 1 || endPort > 65535 || endPort < startPort {
//结束端口不合法
fmt.Println("'endPort' Setting error")
return
}
} else {
//未指定结束端口
endPort = 65535
}
for i := 0; startPort+i <= endPort; i++ {
ports = append(ports, startPort+i)
}
} else {
//一个或多个端口
ps := strings.Split(tmpPort, ",")
for i := 0; i < len(ps); i++ {
p, err := strconv.Atoi(ps[i])
if err != nil {
//端口不合法
fmt.Println("'port' Setting error")
return
}
ports = append(ports, p)
}
}
index++
t, err := strconv.Atoi(arg[index])
if err != nil {
//线程不合法
fmt.Println("'thread' Setting error")
return
}
//最大线程2048
if t < 1 {
t = 1
} else if t > 2048 {
t = 2048
}
//传送启动线程数
thread <- t
//生成扫描地址列表
ips := processIp(startIp, endIp)
il := len(ips)
for i := 0; i < il; i++ {
pl := len(ports)
for j := 0; j < pl; j++ {
ipAddrs <- ips[i] + ":" + strconv.Itoa(ports[j])
}
}
close(ipAddrs)
} func main() {
flag.Parse()
if flag.NArg() != 3 && flag.NArg() != 4 {
//参数不合法
fmt.Println("Parameter error")
return
}
//获取参数
args := make([]string, 0, 4)
for i := 0; i < flag.NArg(); i++ {
args = append(args, flag.Arg(i))
}
//启动扫描线程
go runScan()
//启动结果写入线程
go writeResult()
//参数处理
processFlag(args)
//等待退出指令
<-clo
fmt.Println("Exit")
}
05-11 10:49