Go编写工具教程第一课 高并发端口扫描

var wg sync.WautGroup

func Task(){
	defer wg.Done() //wg.Done()表明当前goroutine结束,defer关键字会让wg.Done()操作在Task函数中所有操作执行完再执wg.Done()
	fmt.Printf("任务开始%d\n", i)
	time.Sleep(time.Second) // 模拟运行的时间
	fmt.Printf("任务完成%d\n", i)
}

func DoTask() {
	for i := 0; i < 10; i++ {
		wg.Add(1) //每要启动一个goroutine，就加1
		go Task(i)
	}
	wg.Wait() //阻塞，等待所有goroutine完成
}

ch1 := make(chan int,[缓冲大小]) //如果使用无缓冲区的的channel，必须有接收者，否则报deadlock错误

//channel基本操作
//(1)发送
ch1 <- 10
//(2)接收
val := <- ch //从ch中接受之，并赋给XX
<-ch //从ch中接收值，忽略结果
//(3)关闭
close(ch)

1.对一个关闭的通道再发送值就会导致panic。
2.对一个关闭的通道进行接收会一直获取值直到通道为空。
3.对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。
4.关闭一个已经关闭的通道会导致panic。

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	defaultports := [...]int{21, 22, 23, 25, 80, 443, 8080,
		110, 135, 139, 445, 389, 489, 587, 1433, 1434,
		1521, 1522, 1723, 2121, 3306, 3389, 4899, 5631,
		5632, 5800, 5900, 7071, 43958, 65500, 4444, 8888,
		6789, 4848, 5985, 5986, 8081, 8089, 8443, 10000,
		6379, 7001, 7002}
	var res []int = make([]int,0)
	start := time.Now()
	for _, port := range defaultports {
        //参数1，扫描使用的协议，参数2，IP+端口号，参数3，设置连接超时的时间
		_, err := net.DialTimeout("tcp", "127.0.0.1:"+strconv.Itoa(port), time.Second)
		if err == nil {
			fmt.Printf("端口开放%d\n", port)
			res = append(res, port)
		} else {
			fmt.Printf("端口关闭%d\n", port)
		}
	}
	end := time.Since(start)
	fmt.Println("花费的总时间：", end)
	fmt.Println("开放的端口", res)
}

package PortScan

import (
	"fmt"
	"net"
	"strconv"
	"sync"
	"time"
)

//taskschan中存储要扫描的端口，reschan存储开放的端口号，exitchan存储当前的goroutine是否完成的状态，wgscan 同步goroutine
func Scan(ip string, taskschan chan int, reschan chan int, exitchan chan bool, wgscan *sync.WaitGroup) {
	defer func() {
		fmt.Println("任务完成")
		exitchan <- true
		wgscan.Done()
	}()
	fmt.Println("开始任务")
	for {
		port, ok := <-taskschan
		if !ok {
			break
		}
		_, err := net.DialTimeout("tcp", ip+":"+strconv.Itoa(port), time.Second)
		if err == nil {
			reschan <- port
			fmt.Println("开放的端口", port)
		}
	}
}

package main

import (
	"AstaGo/Tools/PortScan"
	"fmt"
	"sync"
	"time"
)


func main() {
	defaultports := [...]int{21, 22, 23, 25, 80, 443, 8080,
		110, 135, 139, 445, 389, 489, 587, 1433, 1434,
		1521, 1522, 1723, 2121, 3306, 3389, 4899, 5631,
		5632, 5800, 5900, 7071, 43958, 65500, 4444, 8888,
		6789, 4848, 5985, 5986, 8081, 8089, 8443, 10000,
		6379, 7001, 7002}
	taskschan := make(chan int, len(defaultports))
	reschan := make(chan int, len(defaultports))
	exitchan := make(chan bool, 4)
	var wgp sync.WaitGroup
	for _, value := range defaultports {
		taskschan <- value
	}
    //向taskschan中写完数据时，就需要关闭taskschan,否则goroutine会一直认为该channel会写入数据，会一直等待
	close(taskschan)
	start := time.Now()
    //开启四个goroutine执行扫描任务
	for i := 0; i < 4; i++ {
		wgp.Add(1)
		go PortScan.Scan("127.0.0.1", taskschan, reschan, exitchan, &wgp)
	}
	wgp.Wait()
    //判断4个goroutine是否都执行完了，当他们都执行完了写入到reschan，rechan才可以被关闭
	for i := 0; i < 4; i++ {
		<-exitchan
	}
	end := time.Since(start)
	close(exitchan)
	close(reschan)
	for {
		openport, ok := <-reschan
		if !ok {
			break
		}
		fmt.Println("开放的端口：", openport)
	}
	fmt.Println("花费的时间：", end)
}

package PortScan

import (
	"net"
	"sync"
	"time"
)

func Scan(ip string, taskschan chan string, reschan chan string, exitchan chan bool, wgscan *sync.WaitGroup) {
	defer func() {
		exitchan <- true
		wgscan.Done()
	}()
	for {
		port, ok := <-taskschan
		if !ok {
			break
		}
		_, err := net.DialTimeout("tcp", ip+":"+port, time.Second)
		if err == nil {
			reschan <- port
		}
	}
}

package main

import (
	"AstaGo/Tools/PortScan"
	"flag"
	"fmt"
	"strings"
	"sync"
	"time"
)



func main() {
	var scanports []string
	defaultports := [...]string{"21", "22", "23", "25", "80", "443", "8080",
		"110", "135", "139", "445", "389", "489", "587", "1433", "1434",
		"1521", "1522", "1723", "2121", "3306", "3389", "4899", "5631",
		"5632", "5800", "5900", "7071", "43958", "65500", "4444", "8888",
		"6789", "4848", "5985", "5986", "8081", "8089", "8443", "10000",
		"6379", "7001", "7002"}
	var ip string
	var ports string
	var gonum int
	flag.StringVar(&ip, "i", "127.0.0.1", "扫描的IP地址，默认本机地址")
	flag.StringVar(&ports, "p", "", "扫描的端口地址，默认使用默认端口")
	flag.IntVar(&gonum, "g", 4, "开启的goroutine的数量，默认为4")
	flag.Parse()
	if len(ports) != 0 {
		scanports = strings.Split(ports, ",")
	} else {
		scanports = defaultports[:]
	}
	taskschan := make(chan string, len(scanports))
	reschan := make(chan string, len(scanports))
	exitchan := make(chan bool, 4)
	var wgp sync.WaitGroup
	for _, value := range scanports {
		taskschan <- value
	}
	close(taskschan)
	start := time.Now()
	for i := 0; i < gonum; i++ {
		wgp.Add(1)
		go PortScan.Scan("127.0.0.1", taskschan, reschan, exitchan, &wgp)
	}
	wgp.Wait()
	for i := 0; i < gonum; i++ {
		<-exitchan
	}
	end := time.Since(start)
	close(exitchan)
	close(reschan)
	for {
		openport, ok := <-reschan
		if !ok {
			break
		}
		fmt.Println("开放的端口：", openport)
	}
	fmt.Println("花费的时间：", end)
}