golang快速扫描

利用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")
}